timestamp: Number()

in src/datasource.ts [107:199]

• 4 lines of code
• 5 McCabe index (conditional complexity)

        timestamp: Number(time) / 1000000,
        fields: attributeArray,
      });
    }
  }
  return traceLogs;
}

function transformSpan(df: DataFrame): TraceSpanRow[] {
  let traceSpanRows: TraceSpanRow[] = [];
  const fields = df.fields;
  const result = new Map(fields.map((key) => [key.name, key.values]));
  for (let i = 0; i < df.length; i++) {
    const tsd = {
      traceID: result.get('traceID')?.get(i),
      spanID: result.get('spanID')?.get(i),
      parentSpanID: result.get('parentSpanID')?.get(i),
      operationName: result.get('operationName')?.get(i),
      serviceName: result.get('serviceName')?.get(i),
      serviceTags: transServiceTags(result, i),
      startTime: result.get('startTime')?.get(i),
      duration: result.get('duration')?.get(i),
      tags: transTags(result, i),
      errorIconColor: result.get('statusCode')?.get(i) === 'ERROR' ? '#f00' : '',
      logs: transLogs(result, i),
    };
    traceSpanRows.push(tsd);
  }
  return traceSpanRows;
}

export function transformResponse(df: DataFrame): DataFrame {
  const spanRows = transformSpan(df);
  const frame = new MutableDataFrame({
    fields: [
      { name: 'traceID', type: FieldType.string },
      { name: 'spanID', type: FieldType.string },
      { name: 'parentSpanID', type: FieldType.string },
      { name: 'operationName', type: FieldType.string },
      { name: 'serviceName', type: FieldType.string },
      { name: 'serviceTags', type: FieldType.other },
      { name: 'startTime', type: FieldType.number },
      { name: 'duration', type: FieldType.number },
      { name: 'logs', type: FieldType.other },
      { name: 'tags', type: FieldType.other },
      { name: 'errorIconColor', type: FieldType.string },
    ],
    meta: {
      preferredVisualisationType: 'trace',
    },
  });

  for (const span of spanRows) {
    frame.add(span);
  }

  return frame;
}

function responseToDataQueryResponse(response: DataQueryResponse): DataQueryResponse {
  return {
    data: [transformResponse(response.data[0])],
  };
}

export function mapToTextValue(result: any) {
  if (Array.isArray(result) && result.length === 2) {
    return _.map(result[0], (d, i) => {
      return { text: d, value: result[1][i] };
    });
  }
  return _.map(result[0], (d, i) => {
    if (d && d.text && d.value) {
      return { text: d.text, value: d.value };
    } else if (_.isObject(d)) {
      return { text: d, value: i };
    }
    return { text: d, value: d };
  });
}

export function mapToTextValueNew(frames: any): MetricFindValue[] {

  if(!frames || !Array.isArray(frames) || frames?.length === 0 ) {
    return []
  }

  const TextValues: MetricFindValue[] = [];
  for(const frame of frames) {
    if(frame.data?.values?.length > 0) {
      const fieldsValues = frame.data.values
      // 如果只有两列 默认第一列为text
      if(fieldsValues.length === 2) {