@genkit-ai/telemetry-server/lib/esm/utils/otlp.js

Genkit AI telemetry server

export function fromOtlpValue(value) {
    if (value.stringValue !== undefined)
        return value.stringValue;
    if (value.intValue !== undefined)
        return value.intValue;
    if (value.boolValue !== undefined)
        return value.boolValue;
    if (value.arrayValue !== undefined)
        return value.arrayValue.values.map(fromOtlpValue);
    return undefined;
}
function toMillis(nano) {
    return Math.round(parseInt(nano) / 1000000);
}
function toSpanData(span, scope) {
    const attributes = {};
    span.attributes.forEach((attr) => {
        const val = fromOtlpValue(attr.value);
        if (val !== undefined) {
            attributes[attr.key] = val;
        }
    });
    let spanKind;
    switch (span.kind) {
        case 1:
            spanKind = 'INTERNAL';
            break;
        case 2:
            spanKind = 'SERVER';
            break;
        case 3:
            spanKind = 'CLIENT';
            break;
        case 4:
            spanKind = 'PRODUCER';
            break;
        case 5:
            spanKind = 'CONSUMER';
            break;
        default:
            spanKind = 'UNSPECIFIED';
            break;
    }
    const spanData = {
        traceId: span.traceId,
        spanId: span.spanId,
        parentSpanId: span.parentSpanId,
        startTime: toMillis(span.startTimeUnixNano),
        endTime: toMillis(span.endTimeUnixNano),
        displayName: span.name,
        attributes,
        instrumentationLibrary: {
            name: scope.name,
            version: scope.version,
        },
        spanKind,
    };
    if (span.status && span.status.code !== 0) {
        const status = {
            code: span.status.code,
        };
        if (span.status.message) {
            status.message = span.status.message;
        }
        spanData.status = status;
    }
    return spanData;
}
export function traceDataFromOtlp(otlpData) {
    const traces = {};
    if (otlpData.resourceSpans) {
        otlpData.resourceSpans.forEach((resourceSpan) => {
            resourceSpan.scopeSpans.forEach((scopeSpan) => {
                scopeSpan.spans.forEach((span) => {
                    if (!traces[span.traceId]) {
                        traces[span.traceId] = {
                            traceId: span.traceId,
                            spans: {},
                        };
                    }
                    traces[span.traceId].spans[span.spanId] = toSpanData(span, scopeSpan.scope);
                });
            });
        });
    }
    return Object.values(traces);
}
function toLogRecordData(log, scope) {
    const attributes = {};
    if (log.attributes) {
        log.attributes.forEach((attr) => {
            const val = fromOtlpValue(attr.value);
            if (val !== undefined) {
                attributes[attr.key] = val;
            }
        });
    }
    let body = undefined;
    if (log.body) {
        body = fromOtlpValue(log.body);
    }
    return {
        logId: '',
        traceId: log.traceId,
        spanId: log.spanId,
        timestamp: toMillis(log.timeUnixNano),
        severityNumber: log.severityNumber,
        severityText: log.severityText,
        body,
        attributes,
        instrumentationLibrary: {
            name: scope.name,
            version: scope.version,
        },
    };
}
export function logDataFromOtlp(otlpData) {
    const logs = [];
    if (!otlpData.resourceLogs)
        return logs;
    otlpData.resourceLogs.forEach((resourceLog) => {
        resourceLog.scopeLogs.forEach((scopeLog) => {
            scopeLog.logRecords.forEach((log) => {
                logs.push(toLogRecordData(log, scopeLog.scope));
            });
        });
    });
    return logs;
}
//# sourceMappingURL=otlp.js.map