@perses-dev/tempo-plugin 0.46.0 → 0.47.0-rc0

package/dist/cjs/model/api-types.js

@@ -10,7 +10,29 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-"use strict";
+/**
+ * Common types
+ */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    SpanStatusError: function() {
+        return SpanStatusError;
+    },
+    SpanStatusOk: function() {
+        return SpanStatusOk;
+    },
+    SpanStatusUnset: function() {
+        return SpanStatusUnset;
+    }
+});
+const SpanStatusUnset = 'STATUS_CODE_UNSET';
+const SpanStatusOk = 'STATUS_CODE_OK';
+const SpanStatusError = 'STATUS_CODE_ERROR';

package/dist/cjs/model/tempo-client.js

@@ -24,64 +24,87 @@ _export(exports, {
     executeRequest: function() {
         return executeRequest;
     },
-    getEnrichedTraceQuery: function() {
-        return getEnrichedTraceQuery;
-    },
     searchTraceID: function() {
         return searchTraceID;
     },
     searchTraceQuery: function() {
         return searchTraceQuery;
+    },
+    searchTraceQueryFallback: function() {
+        return searchTraceQueryFallback;
     }
 });
 const _core = require("@perses-dev/core");
-const executeRequest = async (url)=>{
-    const response = await (0, _core.fetch)(url);
+const _apitypes = require("./api-types");
+const executeRequest = async (...args)=>{
+    const response = await (0, _core.fetch)(...args);
     const jsonData = await response.json();
     return jsonData;
 };
-function fetchWithGet(apiURI, datasourceUrl) {
-    const url = `${datasourceUrl}${apiURI}`;
-    return executeRequest(url);
+function fetchWithGet(apiURI, params, queryOptions) {
+    const { datasourceUrl, headers = {} } = queryOptions;
+    let url = `${datasourceUrl}${apiURI}`;
+    if (params) {
+        url += '?' + new URLSearchParams(params);
+    }
+    const init = {
+        method: 'GET',
+        headers
+    };
+    return executeRequest(url, init);
 }
-function searchTraceQuery(query, datasourceUrl) {
-    return fetchWithGet(`/api/search?q=${query}`, datasourceUrl);
+function searchTraceQuery(params, queryOptions) {
+    return fetchWithGet(`/api/search`, params, queryOptions);
 }
-function searchTraceID(traceID, datasourceUrl) {
-    return fetchWithGet(`/api/traces/${traceID}`, datasourceUrl);
+function searchTraceID(traceID, queryOptions) {
+    return fetchWithGet(`/api/traces/${traceID}`, null, queryOptions);
 }
-async function getEnrichedTraceQuery(query, datasourceUrl) {
+async function searchTraceQueryFallback(params, queryOptions) {
+    var _searchResponse_traces_;
     // Get a list of traces that satisfy the query.
-    const searchResponse = await searchTraceQuery(query, datasourceUrl);
-    if (!searchResponse.traces) {
+    const searchResponse = await searchTraceQuery(params, queryOptions);
+    if (!searchResponse.traces || searchResponse.traces.length === 0) {
         return {
-            query,
             traces: []
         };
     }
+    // exit early if fallback is not required (serviceStats are contained in the response)
+    if ((_searchResponse_traces_ = searchResponse.traces[0]) === null || _searchResponse_traces_ === void 0 ? void 0 : _searchResponse_traces_.serviceStats) {
+        return searchResponse;
+    }
+    // calculate serviceStats (number of spans and errors) per service
     return {
-        query,
         traces: await Promise.all(searchResponse.traces.map(async (trace)=>{
-            let spanCount = 0;
-            let errorCount = 0;
-            const searchTraceIDResponse = await searchTraceID(trace.traceID, datasourceUrl);
-            // For every trace, get the full trace, and find the total number of spans and errors.
+            const serviceStats = {};
+            const searchTraceIDResponse = await searchTraceID(trace.traceID, queryOptions);
+            // For every trace, get the full trace, and find the number of spans and errors.
             for (const batch of searchTraceIDResponse.batches){
+                let serviceName = '?';
+                for (const attr of batch.resource.attributes){
+                    if (attr.key === 'service.name' && 'stringValue' in attr.value) {
+                        serviceName = attr.value.stringValue;
+                        break;
+                    }
+                }
+                var _serviceStats_serviceName;
+                const stats = (_serviceStats_serviceName = serviceStats[serviceName]) !== null && _serviceStats_serviceName !== void 0 ? _serviceStats_serviceName : {
+                    spanCount: 0
+                };
                 for (const scopeSpan of batch.scopeSpans){
-                    spanCount += scopeSpan.spans.length;
+                    stats.spanCount += scopeSpan.spans.length;
                     for (const span of scopeSpan.spans){
                         var _span_status;
-                        if ((_span_status = span.status) === null || _span_status === void 0 ? void 0 : _span_status.code) {
-                            errorCount++;
+                        if (((_span_status = span.status) === null || _span_status === void 0 ? void 0 : _span_status.code) === _apitypes.SpanStatusError) {
+                            var _stats_errorCount;
+                            stats.errorCount = ((_stats_errorCount = stats.errorCount) !== null && _stats_errorCount !== void 0 ? _stats_errorCount : 0) + 1;
                         }
                     }
                 }
+                serviceStats[serviceName] = stats;
             }
             return {
-                summary: trace,
-                traceDetails: searchTraceIDResponse,
-                spanCount,
-                errorCount
+                ...trace,
+                serviceStats
             };
         }))
     };

package/dist/cjs/plugins/tempo-datasource.js

@@ -35,9 +35,9 @@ const _tempoclient = require("../model/tempo-client");
         options: {
             datasourceUrl
         },
-        searchTraceQuery: (query)=>(0, _tempoclient.searchTraceQuery)(query, datasourceUrl),
-        searchTraceID: (traceID)=>(0, _tempoclient.searchTraceID)(traceID, datasourceUrl),
-        getEnrichedTraceQuery: (query)=>(0, _tempoclient.getEnrichedTraceQuery)(query, datasourceUrl)
+        searchTraceQuery: (params, queryOptions)=>(0, _tempoclient.searchTraceQuery)(params, queryOptions),
+        searchTraceQueryFallback: (params, queryOptions)=>(0, _tempoclient.searchTraceQueryFallback)(params, queryOptions),
+        searchTraceID: (traceID, queryOptions)=>(0, _tempoclient.searchTraceID)(traceID, queryOptions)
     };
 };
 const TempoDatasource = {

package/dist/cjs/plugins/tempo-trace-query/TempoTraceQuery.js

@@ -26,7 +26,7 @@ const TempoTraceQuery = {
     getTraceData: _gettracedata.getTraceData,
     OptionsEditorComponent: _TempoTraceQueryEditor.TempoTraceQueryEditor,
     createInitialOptions: ()=>({
-            query: '{}',
+            query: '',
             datasource: undefined
         })
 };

package/dist/cjs/plugins/tempo-trace-query/get-trace-data.js

@@ -28,7 +28,9 @@ _export(exports, {
         return getUnixTimeRange;
     }
 });
+const _core = require("@perses-dev/core");
 const _datefns = require("date-fns");
+const _lodash = require("lodash");
 const _temposelectors = require("../../model/tempo-selectors");
 function getUnixTimeRange(timeRange) {
     const { start, end } = timeRange;
@@ -43,7 +45,7 @@ const getTraceData = async (spec, context)=>{
         // Do not make a request to the backend, instead return an empty TraceData
         console.error('TempoTraceQuery is undefined, null, or an empty string.');
         return {
-            traces: []
+            searchResult: []
         };
     }
     const defaultTempoDatasource = {
@@ -55,47 +57,141 @@ const getTraceData = async (spec, context)=>{
     if (datasourceUrl === undefined || datasourceUrl === null || datasourceUrl === '') {
         console.error('TempoDatasource is undefined, null, or an empty string.');
         return {
-            traces: []
+            searchResult: []
         };
     }
     const getQuery = ()=>{
         // if time range not defined -- only return the query from the spec
         if (context.absoluteTimeRange === undefined) {
-            return spec.query;
-        }
-        // if the query already contains a time range (i.e.start and end times)
-        if (spec.query.includes('start=') || spec.query.includes('end=')) {
-            return spec.query;
+            return {
+                q: spec.query
+            };
         }
         // handle time range selection from UI drop down (e.g. last 5 minutes, last 1 hour )
         const { start, end } = getUnixTimeRange(context === null || context === void 0 ? void 0 : context.absoluteTimeRange);
-        const queryStartTime = '&start=' + start;
-        const queryEndTime = '&end=' + end;
-        const queryWithTimeRange = encodeURI(spec.query) + queryStartTime + queryEndTime;
-        return queryWithTimeRange;
+        return {
+            q: spec.query,
+            start,
+            end
+        };
     };
-    const enrichedTraceResponse = await client.getEnrichedTraceQuery(getQuery(), datasourceUrl);
-    const traces = enrichedTraceResponse.traces.map((traceValue)=>{
-        const startTimeUnixMs = parseInt(traceValue.summary.startTimeUnixNano) * 1e-6; // convert to millisecond for eChart time format
-        const durationMs = traceValue.summary.durationMs;
-        const spanCount = traceValue.spanCount;
-        const errorCount = traceValue.errorCount;
-        const traceId = traceValue.summary.traceID;
-        const name = `rootServiceName="${traceValue.summary.rootServiceName.trim()}", rootTraceName="${traceValue.summary.rootServiceName.trim()}"`;
+    /**
+   * determine type of query:
+   * if the query is a valid traceId, fetch the trace by traceId
+   * otherwise, execute a TraceQL query
+   */ if ((0, _core.isValidTraceId)(spec.query)) {
+        const response = await client.searchTraceID(spec.query, {
+            datasourceUrl
+        });
         return {
-            startTimeUnixMs,
-            durationMs,
-            spanCount,
-            errorCount,
-            traceId,
-            name
+            trace: parseTraceResponse(response),
+            metadata: {
+                executedQueryString: spec.query
+            }
         };
-    });
-    const traceData = {
-        traces,
-        metadata: {
-            executedQueryString: spec.query
+    } else {
+        const response = await client.searchTraceQueryFallback(getQuery(), {
+            datasourceUrl
+        });
+        return {
+            searchResult: parseSearchResponse(response),
+            metadata: {
+                executedQueryString: spec.query
+            }
+        };
+    }
+};
+function parseResource(resource) {
+    let serviceName = 'unknown';
+    for (const attr of resource.attributes){
+        if (attr.key === 'service.name' && 'stringValue' in attr.value) {
+            serviceName = attr.value.stringValue;
+            break;
         }
+    }
+    return {
+        serviceName,
+        attributes: resource.attributes
     };
-    return traceData;
-};
+}
+function parseEvent(event) {
+    return {
+        timeUnixMs: parseInt(event.timeUnixNano) * 1e-6,
+        name: event.name,
+        attributes: event.attributes || []
+    };
+}
+/**
+ * parseSpan parses the Span API type to the internal representation
+ * i.e. convert strings to numbers etc.
+ */ function parseSpan(span) {
+    return {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        parentSpanId: span.parentSpanId,
+        name: span.name,
+        kind: span.kind,
+        startTimeUnixMs: parseInt(span.startTimeUnixNano) * 1e-6,
+        endTimeUnixMs: parseInt(span.endTimeUnixNano) * 1e-6,
+        attributes: span.attributes || [],
+        events: (span.events || []).map(parseEvent),
+        status: span.status
+    };
+}
+/**
+ * parseTraceResponse builds a tree of spans from the Tempo API response
+ * time complexity: O(2n)
+ */ function parseTraceResponse(response) {
+    // first pass: build lookup table <spanId, Span>
+    const lookup = new Map();
+    for (const batch of response.batches){
+        const resource = parseResource(batch.resource);
+        for (const scopeSpan of batch.scopeSpans){
+            const scope = scopeSpan.scope;
+            for (const tempoSpan of scopeSpan.spans){
+                const span = {
+                    resource,
+                    scope,
+                    childSpans: [],
+                    ...parseSpan(tempoSpan)
+                };
+                lookup.set(tempoSpan.spanId, span);
+            }
+        }
+    }
+    // second pass: build tree based on parentSpanId property
+    let rootSpan = null;
+    for (const [, span] of lookup){
+        if (!span.parentSpanId) {
+            rootSpan = span;
+        } else {
+            const parent = lookup.get(span.parentSpanId);
+            if (!parent) {
+                console.error(`span ${span.spanId} has parent ${span.parentSpanId} which has not been received yet`);
+                continue;
+            }
+            span.parentSpan = parent;
+            const insertChildSpanAt = (0, _lodash.sortedIndexBy)(parent.childSpans, span, (s)=>s.startTimeUnixMs);
+            parent.childSpans.splice(insertChildSpanAt, 0, span);
+        }
+    }
+    if (!rootSpan) {
+        throw new Error('root span not found');
+    }
+    return {
+        rootSpan
+    };
+}
+function parseSearchResponse(response) {
+    return response.traces.map((trace)=>{
+        var _trace_durationMs;
+        return {
+            startTimeUnixMs: parseInt(trace.startTimeUnixNano) * 1e-6,
+            durationMs: (_trace_durationMs = trace.durationMs) !== null && _trace_durationMs !== void 0 ? _trace_durationMs : 0,
+            traceId: trace.traceID,
+            rootServiceName: trace.rootServiceName,
+            rootTraceName: trace.rootTraceName,
+            serviceStats: trace.serviceStats || {}
+        };
+    });
+}