wehub-resource-sync
931 lines
30 KiB
TypeScript
931 lines
30 KiB
TypeScript
// Worker-safe OTLP transform: no server singletons (env/clickhouse/repository/prisma).
|
|
import { SemanticInternalAttributes } from "@trigger.dev/core/v3";
|
|
import type {
|
|
AnyValue,
|
|
KeyValue,
|
|
ResourceLogs,
|
|
ResourceMetrics,
|
|
ResourceSpans,
|
|
Span,
|
|
Span_Event,
|
|
} from "@trigger.dev/otlp-importer";
|
|
import { SeverityNumber, Span_SpanKind, Status_StatusCode } from "@trigger.dev/otlp-importer";
|
|
import type { MetricsV1Input } from "@internal/clickhouse";
|
|
import { generateSpanId } from "./eventRepository/common.server";
|
|
import type {
|
|
CreatableEventKind,
|
|
CreatableEventStatus,
|
|
CreateEventInput,
|
|
} from "./eventRepository/eventRepository.types";
|
|
|
|
// Filters mirror OTLPExporter's #filterResource* methods, minus the debug logging, so a
|
|
// worker can run them without the server logger.
|
|
export function filterResourceSpans(resourceSpans: ResourceSpans[]): ResourceSpans[] {
|
|
return resourceSpans.filter((resourceSpan) => {
|
|
const triggerAttribute = resourceSpan.resource?.attributes.find(
|
|
(attribute) => attribute.key === SemanticInternalAttributes.TRIGGER
|
|
);
|
|
const executionEnvironmentAttribute = resourceSpan.resource?.attributes.find(
|
|
(attribute) => attribute.key === SemanticInternalAttributes.EXECUTION_ENVIRONMENT
|
|
);
|
|
|
|
if (!triggerAttribute && !executionEnvironmentAttribute) return true;
|
|
|
|
const executionEnvironment = isStringValue(executionEnvironmentAttribute?.value)
|
|
? executionEnvironmentAttribute.value.stringValue
|
|
: undefined;
|
|
if (executionEnvironment === "trigger") return true;
|
|
|
|
return isBoolValue(triggerAttribute?.value) ? triggerAttribute.value.boolValue : false;
|
|
});
|
|
}
|
|
|
|
export function filterResourceLogs(resourceLogs: ResourceLogs[]): ResourceLogs[] {
|
|
return resourceLogs.filter((resourceLog) => {
|
|
const attribute = resourceLog.resource?.attributes.find(
|
|
(attribute) => attribute.key === SemanticInternalAttributes.TRIGGER
|
|
);
|
|
if (!attribute) return false;
|
|
return isBoolValue(attribute.value) ? attribute.value.boolValue : false;
|
|
});
|
|
}
|
|
|
|
export function filterResourceMetrics(resourceMetrics: ResourceMetrics[]): ResourceMetrics[] {
|
|
return resourceMetrics.filter((rm) => {
|
|
const triggerAttribute = rm.resource?.attributes.find(
|
|
(attribute) => attribute.key === SemanticInternalAttributes.TRIGGER
|
|
);
|
|
if (!triggerAttribute) return false;
|
|
return isBoolValue(triggerAttribute.value) ? triggerAttribute.value.boolValue : false;
|
|
});
|
|
}
|
|
|
|
export function convertLogsToCreateableEvents(
|
|
resourceLog: ResourceLogs,
|
|
spanAttributeValueLengthLimit: number,
|
|
defaultEventStore: string
|
|
): { events: Array<CreateEventInput>; taskEventStore: string } {
|
|
const resourceAttributes = resourceLog.resource?.attributes ?? [];
|
|
|
|
const resourceProperties = extractEventProperties(resourceAttributes);
|
|
|
|
const userDefinedResourceAttributes = truncateAttributes(
|
|
convertKeyValueItemsToMap(resourceAttributes ?? [], [], undefined, [
|
|
SemanticInternalAttributes.USAGE,
|
|
SemanticInternalAttributes.SPAN,
|
|
SemanticInternalAttributes.METADATA,
|
|
SemanticInternalAttributes.STYLE,
|
|
SemanticInternalAttributes.METRIC_EVENTS,
|
|
SemanticInternalAttributes.TRIGGER,
|
|
"process",
|
|
"sdk",
|
|
"service",
|
|
"ctx",
|
|
"cli",
|
|
"cloud",
|
|
]),
|
|
spanAttributeValueLengthLimit
|
|
);
|
|
|
|
const taskEventStore =
|
|
extractStringAttribute(resourceAttributes, [SemanticInternalAttributes.TASK_EVENT_STORE]) ??
|
|
defaultEventStore;
|
|
|
|
const events = resourceLog.scopeLogs.flatMap((scopeLog) => {
|
|
return scopeLog.logRecords
|
|
.map((log) => {
|
|
const logLevel = logLevelToEventLevel(log.severityNumber);
|
|
|
|
if (!log.traceId || !log.spanId) {
|
|
return;
|
|
}
|
|
|
|
const logProperties = extractEventProperties(
|
|
log.attributes ?? [],
|
|
SemanticInternalAttributes.METADATA
|
|
);
|
|
|
|
const properties =
|
|
truncateAttributes(
|
|
convertKeyValueItemsToMap(log.attributes ?? [], [], undefined, [
|
|
SemanticInternalAttributes.USAGE,
|
|
SemanticInternalAttributes.SPAN,
|
|
SemanticInternalAttributes.METADATA,
|
|
SemanticInternalAttributes.STYLE,
|
|
SemanticInternalAttributes.METRIC_EVENTS,
|
|
SemanticInternalAttributes.TRIGGER,
|
|
]),
|
|
spanAttributeValueLengthLimit
|
|
) ?? {};
|
|
|
|
return {
|
|
traceId: binaryToHex(log.traceId),
|
|
spanId: generateSpanId(),
|
|
parentId: binaryToHex(log.spanId),
|
|
message: isStringValue(log.body)
|
|
? log.body.stringValue.slice(0, 4096)
|
|
: `${log.severityText} log`,
|
|
isPartial: false,
|
|
kind: "INTERNAL" as const,
|
|
level: logLevelToEventLevel(log.severityNumber),
|
|
isError: logLevel === "ERROR",
|
|
status: logLevelToEventStatus(log.severityNumber),
|
|
startTime: log.timeUnixNano,
|
|
properties,
|
|
resourceProperties: userDefinedResourceAttributes,
|
|
style: convertKeyValueItemsToMap(
|
|
pickAttributes(log.attributes ?? [], SemanticInternalAttributes.STYLE),
|
|
[]
|
|
),
|
|
metadata: logProperties.metadata ?? resourceProperties.metadata ?? {},
|
|
environmentId:
|
|
logProperties.environmentId ?? resourceProperties.environmentId ?? "unknown",
|
|
environmentType: "DEVELOPMENT" as const, // We've deprecated this but we need to keep it for backwards compatibility
|
|
organizationId:
|
|
logProperties.organizationId ?? resourceProperties.organizationId ?? "unknown",
|
|
projectId: logProperties.projectId ?? resourceProperties.projectId ?? "unknown",
|
|
runId: logProperties.runId ?? resourceProperties.runId ?? "unknown",
|
|
taskSlug: logProperties.taskSlug ?? resourceProperties.taskSlug ?? "unknown",
|
|
machineId: logProperties.machineId ?? resourceProperties.machineId,
|
|
attemptNumber:
|
|
extractNumberAttribute(
|
|
log.attributes ?? [],
|
|
[SemanticInternalAttributes.METADATA, SemanticInternalAttributes.ATTEMPT_NUMBER].join(
|
|
"."
|
|
)
|
|
) ?? resourceProperties.attemptNumber,
|
|
};
|
|
})
|
|
.filter(Boolean);
|
|
});
|
|
|
|
return { events, taskEventStore };
|
|
}
|
|
|
|
export function convertSpansToCreateableEvents(
|
|
resourceSpan: ResourceSpans,
|
|
spanAttributeValueLengthLimit: number,
|
|
defaultEventStore: string
|
|
): { events: Array<CreateEventInput>; taskEventStore: string } {
|
|
const resourceAttributes = resourceSpan.resource?.attributes ?? [];
|
|
|
|
const resourceProperties = extractEventProperties(resourceAttributes);
|
|
|
|
const userDefinedResourceAttributes = truncateAttributes(
|
|
convertKeyValueItemsToMap(resourceAttributes ?? [], [], undefined, [
|
|
SemanticInternalAttributes.USAGE,
|
|
SemanticInternalAttributes.SPAN,
|
|
SemanticInternalAttributes.METADATA,
|
|
SemanticInternalAttributes.STYLE,
|
|
SemanticInternalAttributes.METRIC_EVENTS,
|
|
SemanticInternalAttributes.TRIGGER,
|
|
"process",
|
|
"sdk",
|
|
"service",
|
|
"ctx",
|
|
"cli",
|
|
"cloud",
|
|
]),
|
|
spanAttributeValueLengthLimit
|
|
);
|
|
|
|
const taskEventStore =
|
|
extractStringAttribute(resourceAttributes, [SemanticInternalAttributes.TASK_EVENT_STORE]) ??
|
|
defaultEventStore;
|
|
|
|
const events = resourceSpan.scopeSpans.flatMap((scopeSpan) => {
|
|
return scopeSpan.spans
|
|
.map((span) => {
|
|
const isPartial = isPartialSpan(span);
|
|
|
|
if (!span.traceId || !span.spanId) {
|
|
return;
|
|
}
|
|
|
|
const spanProperties = extractEventProperties(
|
|
span.attributes ?? [],
|
|
SemanticInternalAttributes.METADATA
|
|
);
|
|
|
|
const runTags = extractArrayAttribute(
|
|
span.attributes ?? [],
|
|
SemanticInternalAttributes.RUN_TAGS
|
|
);
|
|
|
|
const properties =
|
|
truncateAttributes(
|
|
convertKeyValueItemsToMap(span.attributes ?? [], [], undefined, [
|
|
SemanticInternalAttributes.USAGE,
|
|
SemanticInternalAttributes.SPAN,
|
|
SemanticInternalAttributes.METADATA,
|
|
SemanticInternalAttributes.STYLE,
|
|
SemanticInternalAttributes.METRIC_EVENTS,
|
|
SemanticInternalAttributes.TRIGGER,
|
|
]),
|
|
spanAttributeValueLengthLimit
|
|
) ?? {};
|
|
|
|
return {
|
|
traceId: binaryToHex(span.traceId),
|
|
spanId: isPartial
|
|
? extractStringAttribute(
|
|
span?.attributes ?? [],
|
|
SemanticInternalAttributes.SPAN_ID,
|
|
binaryToHex(span.spanId)
|
|
)
|
|
: binaryToHex(span.spanId),
|
|
parentId: binaryToHex(span.parentSpanId),
|
|
message: span.name,
|
|
isPartial,
|
|
isError: span.status?.code === Status_StatusCode.ERROR,
|
|
kind: spanKindToEventKind(span.kind),
|
|
level: "TRACE" as const,
|
|
status: spanStatusToEventStatus(span.status),
|
|
startTime: span.startTimeUnixNano,
|
|
events: spanEventsToEventEvents(span.events ?? []),
|
|
duration: span.endTimeUnixNano - span.startTimeUnixNano,
|
|
properties,
|
|
resourceProperties: userDefinedResourceAttributes,
|
|
style: convertKeyValueItemsToMap(
|
|
pickAttributes(span.attributes ?? [], SemanticInternalAttributes.STYLE),
|
|
[]
|
|
),
|
|
metadata: spanProperties.metadata ?? resourceProperties.metadata ?? {},
|
|
environmentId:
|
|
spanProperties.environmentId ?? resourceProperties.environmentId ?? "unknown",
|
|
environmentType: "DEVELOPMENT" as const,
|
|
organizationId:
|
|
spanProperties.organizationId ?? resourceProperties.organizationId ?? "unknown",
|
|
projectId: spanProperties.projectId ?? resourceProperties.projectId ?? "unknown",
|
|
runId: spanProperties.runId ?? resourceProperties.runId ?? "unknown",
|
|
taskSlug: spanProperties.taskSlug ?? resourceProperties.taskSlug ?? "unknown",
|
|
machineId: spanProperties.machineId ?? resourceProperties.machineId,
|
|
runTags,
|
|
attemptNumber:
|
|
extractNumberAttribute(
|
|
span.attributes ?? [],
|
|
[SemanticInternalAttributes.METADATA, SemanticInternalAttributes.ATTEMPT_NUMBER].join(
|
|
"."
|
|
)
|
|
) ?? resourceProperties.attemptNumber,
|
|
};
|
|
})
|
|
.filter(Boolean);
|
|
});
|
|
|
|
return { events, taskEventStore };
|
|
}
|
|
|
|
function floorToTenSecondBucket(timeUnixNano: bigint | number): string {
|
|
const epochMs = Number(BigInt(timeUnixNano) / BigInt(1_000_000));
|
|
const flooredMs = Math.floor(epochMs / 10_000) * 10_000;
|
|
const date = new Date(flooredMs);
|
|
// Format as ClickHouse DateTime: YYYY-MM-DD HH:MM:SS
|
|
return date
|
|
.toISOString()
|
|
.replace("T", " ")
|
|
.replace(/\.\d{3}Z$/, "");
|
|
}
|
|
|
|
export function convertMetricsToClickhouseRows(
|
|
resourceMetrics: ResourceMetrics,
|
|
spanAttributeValueLengthLimit: number
|
|
): MetricsV1Input[] {
|
|
const resourceAttributes = resourceMetrics.resource?.attributes ?? [];
|
|
const resourceProperties = extractEventProperties(resourceAttributes);
|
|
|
|
const organizationId = resourceProperties.organizationId ?? "unknown";
|
|
const projectId = resourceProperties.projectId ?? "unknown";
|
|
const environmentId = resourceProperties.environmentId ?? "unknown";
|
|
const resourceCtx = {
|
|
taskSlug: resourceProperties.taskSlug,
|
|
runId: resourceProperties.runId,
|
|
attemptNumber: resourceProperties.attemptNumber,
|
|
machineId: extractStringAttribute(resourceAttributes, SemanticInternalAttributes.MACHINE_ID),
|
|
workerId: extractStringAttribute(resourceAttributes, SemanticInternalAttributes.WORKER_ID),
|
|
workerVersion: extractStringAttribute(
|
|
resourceAttributes,
|
|
SemanticInternalAttributes.WORKER_VERSION
|
|
),
|
|
};
|
|
|
|
const rows: MetricsV1Input[] = [];
|
|
|
|
for (const scopeMetrics of resourceMetrics.scopeMetrics) {
|
|
for (const metric of scopeMetrics.metrics) {
|
|
const metricName = metric.name;
|
|
|
|
// Process gauge data points
|
|
if (metric.gauge) {
|
|
for (const dp of metric.gauge.dataPoints) {
|
|
const value: number =
|
|
dp.asDouble !== undefined ? dp.asDouble : dp.asInt !== undefined ? Number(dp.asInt) : 0;
|
|
const resolved = resolveDataPointContext(dp.attributes ?? [], resourceCtx);
|
|
|
|
rows.push({
|
|
organization_id: organizationId,
|
|
project_id: projectId,
|
|
environment_id: environmentId,
|
|
metric_name: metricName,
|
|
metric_type: "gauge",
|
|
metric_subject: resolved.machineId ?? "unknown",
|
|
bucket_start: floorToTenSecondBucket(dp.timeUnixNano),
|
|
value,
|
|
attributes: resolved.attributes,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Process sum data points
|
|
if (metric.sum) {
|
|
for (const dp of metric.sum.dataPoints) {
|
|
const value: number =
|
|
dp.asDouble !== undefined ? dp.asDouble : dp.asInt !== undefined ? Number(dp.asInt) : 0;
|
|
const resolved = resolveDataPointContext(dp.attributes ?? [], resourceCtx);
|
|
|
|
rows.push({
|
|
organization_id: organizationId,
|
|
project_id: projectId,
|
|
environment_id: environmentId,
|
|
metric_name: metricName,
|
|
metric_type: "sum",
|
|
metric_subject: resolved.machineId ?? "unknown",
|
|
bucket_start: floorToTenSecondBucket(dp.timeUnixNano),
|
|
value,
|
|
attributes: resolved.attributes,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Process histogram data points
|
|
if (metric.histogram) {
|
|
for (const dp of metric.histogram.dataPoints) {
|
|
const resolved = resolveDataPointContext(dp.attributes ?? [], resourceCtx);
|
|
const count = Number(dp.count);
|
|
const sum = dp.sum ?? 0;
|
|
|
|
rows.push({
|
|
organization_id: organizationId,
|
|
project_id: projectId,
|
|
environment_id: environmentId,
|
|
metric_name: metricName,
|
|
metric_type: "histogram",
|
|
metric_subject: resolved.machineId ?? "unknown",
|
|
bucket_start: floorToTenSecondBucket(dp.timeUnixNano),
|
|
value: count > 0 ? sum / count : 0,
|
|
attributes: resolved.attributes,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return rows;
|
|
}
|
|
|
|
// Prefixes injected by TaskContextMetricExporter — these are extracted into
|
|
// the nested `trigger` key and should not appear as top-level user attributes.
|
|
const INTERNAL_METRIC_ATTRIBUTE_PREFIXES = ["ctx.", "worker."];
|
|
|
|
interface ResourceContext {
|
|
taskSlug: string | undefined;
|
|
runId: string | undefined;
|
|
attemptNumber: number | undefined;
|
|
machineId: string | undefined;
|
|
workerId: string | undefined;
|
|
workerVersion: string | undefined;
|
|
}
|
|
|
|
function resolveDataPointContext(
|
|
dpAttributes: KeyValue[],
|
|
resourceCtx: ResourceContext
|
|
): {
|
|
machineId: string | undefined;
|
|
attributes: Record<string, unknown>;
|
|
} {
|
|
const runId =
|
|
resourceCtx.runId ?? extractStringAttribute(dpAttributes, SemanticInternalAttributes.RUN_ID);
|
|
const taskSlug =
|
|
resourceCtx.taskSlug ??
|
|
extractStringAttribute(dpAttributes, SemanticInternalAttributes.TASK_SLUG);
|
|
const attemptNumber =
|
|
resourceCtx.attemptNumber ??
|
|
extractNumberAttribute(dpAttributes, SemanticInternalAttributes.ATTEMPT_NUMBER);
|
|
const machineId =
|
|
resourceCtx.machineId ??
|
|
extractStringAttribute(dpAttributes, SemanticInternalAttributes.MACHINE_ID);
|
|
const workerId =
|
|
resourceCtx.workerId ??
|
|
extractStringAttribute(dpAttributes, SemanticInternalAttributes.WORKER_ID);
|
|
const workerVersion =
|
|
resourceCtx.workerVersion ??
|
|
extractStringAttribute(dpAttributes, SemanticInternalAttributes.WORKER_VERSION);
|
|
const machineName = extractStringAttribute(
|
|
dpAttributes,
|
|
SemanticInternalAttributes.MACHINE_PRESET_NAME
|
|
);
|
|
const environmentType = extractStringAttribute(
|
|
dpAttributes,
|
|
SemanticInternalAttributes.ENVIRONMENT_TYPE
|
|
);
|
|
|
|
// Build the trigger context object with only defined values
|
|
const trigger: Record<string, string | number> = {};
|
|
if (runId) trigger.run_id = runId;
|
|
if (taskSlug) trigger.task_slug = taskSlug;
|
|
if (attemptNumber !== undefined) trigger.attempt_number = attemptNumber;
|
|
if (machineId) trigger.machine_id = machineId;
|
|
if (machineName) trigger.machine_name = machineName;
|
|
if (workerId) trigger.worker_id = workerId;
|
|
if (workerVersion) trigger.worker_version = workerVersion;
|
|
if (environmentType) trigger.environment_type = environmentType;
|
|
|
|
// Build user attributes, filtering out internal ctx/worker keys
|
|
const result: Record<string, unknown> = {};
|
|
|
|
if (Object.keys(trigger).length > 0) {
|
|
result.trigger = trigger;
|
|
}
|
|
|
|
for (const attr of dpAttributes) {
|
|
if (INTERNAL_METRIC_ATTRIBUTE_PREFIXES.some((prefix) => attr.key.startsWith(prefix))) {
|
|
continue;
|
|
}
|
|
|
|
if (isStringValue(attr.value)) {
|
|
result[attr.key] = attr.value.stringValue;
|
|
} else if (isIntValue(attr.value)) {
|
|
result[attr.key] = Number(attr.value.intValue);
|
|
} else if (isDoubleValue(attr.value)) {
|
|
result[attr.key] = attr.value.doubleValue;
|
|
} else if (isBoolValue(attr.value)) {
|
|
result[attr.key] = attr.value.boolValue;
|
|
}
|
|
}
|
|
|
|
return { machineId, attributes: result };
|
|
}
|
|
|
|
function extractEventProperties(attributes: KeyValue[], prefix?: string) {
|
|
return {
|
|
metadata: convertSelectedKeyValueItemsToMap(attributes, [SemanticInternalAttributes.METADATA]),
|
|
environmentId: extractStringAttribute(attributes, [
|
|
prefix,
|
|
SemanticInternalAttributes.ENVIRONMENT_ID,
|
|
]),
|
|
organizationId: extractStringAttribute(attributes, [
|
|
prefix,
|
|
SemanticInternalAttributes.ORGANIZATION_ID,
|
|
]),
|
|
projectId: extractStringAttribute(attributes, [prefix, SemanticInternalAttributes.PROJECT_ID]),
|
|
runId: extractStringAttribute(attributes, [prefix, SemanticInternalAttributes.RUN_ID]),
|
|
attemptNumber: extractNumberAttribute(attributes, [
|
|
prefix,
|
|
SemanticInternalAttributes.ATTEMPT_NUMBER,
|
|
]),
|
|
taskSlug: extractStringAttribute(attributes, [prefix, SemanticInternalAttributes.TASK_SLUG]),
|
|
machineId: extractStringAttribute(attributes, [prefix, SemanticInternalAttributes.MACHINE_ID]),
|
|
};
|
|
}
|
|
|
|
function pickAttributes(attributes: KeyValue[], prefix: string): KeyValue[] {
|
|
return attributes
|
|
.filter((attribute) => attribute.key.startsWith(prefix))
|
|
.map((attribute) => {
|
|
return {
|
|
key: attribute.key.replace(`${prefix}.`, ""),
|
|
value: attribute.value,
|
|
};
|
|
});
|
|
}
|
|
|
|
function convertKeyValueItemsToMap(
|
|
attributes: KeyValue[],
|
|
filteredKeys: string[] = [],
|
|
prefix?: string,
|
|
filteredPrefixes: string[] = []
|
|
): Record<string, string | number | boolean | undefined> | undefined {
|
|
if (!attributes) return;
|
|
if (!attributes.length) return;
|
|
|
|
let filteredAttributes = attributes.filter((attribute) => !filteredKeys.includes(attribute.key));
|
|
|
|
if (!filteredAttributes.length) return;
|
|
|
|
if (filteredPrefixes.length) {
|
|
filteredAttributes = filteredAttributes.filter(
|
|
(attribute) => !filteredPrefixes.some((prefix) => attribute.key.startsWith(prefix))
|
|
);
|
|
}
|
|
|
|
if (!filteredAttributes.length) return;
|
|
|
|
const result = filteredAttributes.reduce(
|
|
(map: Record<string, string | number | boolean | undefined>, attribute) => {
|
|
map[`${prefix ? `${prefix}.` : ""}${attribute.key}`] = isStringValue(attribute.value)
|
|
? attribute.value.stringValue
|
|
: isIntValue(attribute.value)
|
|
? Number(attribute.value.intValue)
|
|
: isDoubleValue(attribute.value)
|
|
? attribute.value.doubleValue
|
|
: isBoolValue(attribute.value)
|
|
? attribute.value.boolValue
|
|
: isBytesValue(attribute.value)
|
|
? binaryToHex(attribute.value.bytesValue)
|
|
: isArrayValue(attribute.value)
|
|
? serializeArrayValue(attribute.value.arrayValue!.values)
|
|
: undefined;
|
|
|
|
return map;
|
|
},
|
|
{}
|
|
);
|
|
|
|
return result;
|
|
}
|
|
|
|
function convertSelectedKeyValueItemsToMap(
|
|
attributes: KeyValue[],
|
|
selectedPrefixes: string[] = [],
|
|
prefix?: string
|
|
): Record<string, string | number | boolean | undefined> | undefined {
|
|
if (!attributes) return;
|
|
if (!attributes.length) return;
|
|
|
|
let selectedAttributes = attributes.filter((attribute) =>
|
|
selectedPrefixes.some((prefix) => attribute.key.startsWith(prefix))
|
|
);
|
|
|
|
if (!selectedAttributes.length) return;
|
|
|
|
const result = selectedAttributes.reduce(
|
|
(map: Record<string, string | number | boolean | undefined>, attribute) => {
|
|
map[`${prefix ? `${prefix}.` : ""}${attribute.key}`] = isStringValue(attribute.value)
|
|
? attribute.value.stringValue
|
|
: isIntValue(attribute.value)
|
|
? Number(attribute.value.intValue)
|
|
: isDoubleValue(attribute.value)
|
|
? attribute.value.doubleValue
|
|
: isBoolValue(attribute.value)
|
|
? attribute.value.boolValue
|
|
: isBytesValue(attribute.value)
|
|
? binaryToHex(attribute.value.bytesValue)
|
|
: isArrayValue(attribute.value)
|
|
? serializeArrayValue(attribute.value.arrayValue!.values)
|
|
: undefined;
|
|
|
|
return map;
|
|
},
|
|
{}
|
|
);
|
|
|
|
return result;
|
|
}
|
|
function spanEventsToEventEvents(events: Span_Event[]): CreateEventInput["events"] {
|
|
return events.map((event) => {
|
|
return {
|
|
name: event.name,
|
|
time: convertUnixNanoToDate(event.timeUnixNano),
|
|
properties: convertKeyValueItemsToMap(event.attributes ?? []),
|
|
};
|
|
});
|
|
}
|
|
|
|
function spanStatusToEventStatus(status: Span["status"]): CreatableEventStatus {
|
|
if (!status) return "UNSET";
|
|
|
|
switch (status.code) {
|
|
case Status_StatusCode.OK: {
|
|
return "OK";
|
|
}
|
|
case Status_StatusCode.ERROR: {
|
|
return "ERROR";
|
|
}
|
|
case Status_StatusCode.UNSET: {
|
|
return "UNSET";
|
|
}
|
|
default: {
|
|
return "UNSET";
|
|
}
|
|
}
|
|
}
|
|
|
|
function spanKindToEventKind(kind: Span["kind"]): CreatableEventKind {
|
|
switch (kind) {
|
|
case Span_SpanKind.CLIENT: {
|
|
return "CLIENT";
|
|
}
|
|
case Span_SpanKind.SERVER: {
|
|
return "SERVER";
|
|
}
|
|
case Span_SpanKind.CONSUMER: {
|
|
return "CONSUMER";
|
|
}
|
|
case Span_SpanKind.PRODUCER: {
|
|
return "PRODUCER";
|
|
}
|
|
default: {
|
|
return "INTERNAL";
|
|
}
|
|
}
|
|
}
|
|
|
|
function logLevelToEventLevel(level: SeverityNumber): CreateEventInput["level"] {
|
|
switch (level) {
|
|
case SeverityNumber.TRACE:
|
|
case SeverityNumber.TRACE2:
|
|
case SeverityNumber.TRACE3:
|
|
case SeverityNumber.TRACE4: {
|
|
return "TRACE";
|
|
}
|
|
case SeverityNumber.DEBUG:
|
|
case SeverityNumber.DEBUG2:
|
|
case SeverityNumber.DEBUG3:
|
|
case SeverityNumber.DEBUG4: {
|
|
return "DEBUG";
|
|
}
|
|
case SeverityNumber.INFO:
|
|
case SeverityNumber.INFO2:
|
|
case SeverityNumber.INFO3:
|
|
case SeverityNumber.INFO4: {
|
|
return "INFO";
|
|
}
|
|
case SeverityNumber.WARN:
|
|
case SeverityNumber.WARN2:
|
|
case SeverityNumber.WARN3:
|
|
case SeverityNumber.WARN4: {
|
|
return "WARN";
|
|
}
|
|
case SeverityNumber.ERROR:
|
|
case SeverityNumber.ERROR2:
|
|
case SeverityNumber.ERROR3:
|
|
case SeverityNumber.ERROR4: {
|
|
return "ERROR";
|
|
}
|
|
case SeverityNumber.FATAL:
|
|
case SeverityNumber.FATAL2:
|
|
case SeverityNumber.FATAL3:
|
|
case SeverityNumber.FATAL4: {
|
|
return "ERROR";
|
|
}
|
|
default: {
|
|
return "INFO";
|
|
}
|
|
}
|
|
}
|
|
|
|
function logLevelToEventStatus(level: SeverityNumber): CreatableEventStatus {
|
|
switch (level) {
|
|
case SeverityNumber.TRACE:
|
|
case SeverityNumber.TRACE2:
|
|
case SeverityNumber.TRACE3:
|
|
case SeverityNumber.TRACE4: {
|
|
return "OK";
|
|
}
|
|
case SeverityNumber.DEBUG:
|
|
case SeverityNumber.DEBUG2:
|
|
case SeverityNumber.DEBUG3:
|
|
case SeverityNumber.DEBUG4: {
|
|
return "OK";
|
|
}
|
|
case SeverityNumber.INFO:
|
|
case SeverityNumber.INFO2:
|
|
case SeverityNumber.INFO3:
|
|
case SeverityNumber.INFO4: {
|
|
return "OK";
|
|
}
|
|
case SeverityNumber.WARN:
|
|
case SeverityNumber.WARN2:
|
|
case SeverityNumber.WARN3:
|
|
case SeverityNumber.WARN4: {
|
|
return "OK";
|
|
}
|
|
case SeverityNumber.ERROR:
|
|
case SeverityNumber.ERROR2:
|
|
case SeverityNumber.ERROR3:
|
|
case SeverityNumber.ERROR4: {
|
|
return "ERROR";
|
|
}
|
|
case SeverityNumber.FATAL:
|
|
case SeverityNumber.FATAL2:
|
|
case SeverityNumber.FATAL3:
|
|
case SeverityNumber.FATAL4: {
|
|
return "ERROR";
|
|
}
|
|
default: {
|
|
return "OK";
|
|
}
|
|
}
|
|
}
|
|
|
|
function convertUnixNanoToDate(unixNano: bigint | number): Date {
|
|
return new Date(Number(BigInt(unixNano) / BigInt(1_000_000)));
|
|
}
|
|
|
|
function extractStringAttribute(
|
|
attributes: KeyValue[],
|
|
name: string | Array<string | undefined>
|
|
): string | undefined;
|
|
function extractStringAttribute(
|
|
attributes: KeyValue[],
|
|
name: string | Array<string | undefined>,
|
|
fallback: string
|
|
): string;
|
|
function extractStringAttribute(
|
|
attributes: KeyValue[],
|
|
name: string | Array<string | undefined>,
|
|
fallback?: string
|
|
): string | undefined {
|
|
const key = Array.isArray(name) ? name.filter(Boolean).join(".") : name;
|
|
|
|
const attribute = attributes.find((attribute) => attribute.key === key);
|
|
|
|
if (!attribute) return fallback;
|
|
|
|
return isStringValue(attribute?.value) ? attribute.value.stringValue : fallback;
|
|
}
|
|
|
|
function extractNumberAttribute(
|
|
attributes: KeyValue[],
|
|
name: string | Array<string | undefined>
|
|
): number | undefined;
|
|
function extractNumberAttribute(
|
|
attributes: KeyValue[],
|
|
name: string | Array<string | undefined>,
|
|
fallback: number
|
|
): number;
|
|
function extractNumberAttribute(
|
|
attributes: KeyValue[],
|
|
name: string | Array<string | undefined>,
|
|
fallback?: number
|
|
): number | undefined {
|
|
const key = Array.isArray(name) ? name.filter(Boolean).join(".") : name;
|
|
|
|
const attribute = attributes.find((attribute) => attribute.key === key);
|
|
|
|
if (!attribute) return fallback;
|
|
|
|
return isIntValue(attribute?.value) ? Number(attribute.value.intValue) : fallback;
|
|
}
|
|
|
|
function extractArrayAttribute(
|
|
attributes: KeyValue[],
|
|
name: string | Array<string | undefined>
|
|
): string[] | undefined {
|
|
const key = Array.isArray(name) ? name.filter(Boolean).join(".") : name;
|
|
|
|
const attribute = attributes.find((attribute) => attribute.key === key);
|
|
|
|
if (!attribute?.value?.arrayValue?.values) return undefined;
|
|
|
|
return attribute.value.arrayValue.values
|
|
.filter((v): v is { stringValue: string } => isStringValue(v))
|
|
.map((v) => v.stringValue);
|
|
}
|
|
|
|
function isPartialSpan(span: Span): boolean {
|
|
if (!span.attributes) return false;
|
|
|
|
const attribute = span.attributes.find(
|
|
(attribute) => attribute.key === SemanticInternalAttributes.SPAN_PARTIAL
|
|
);
|
|
|
|
if (!attribute) return false;
|
|
|
|
return isBoolValue(attribute.value) ? attribute.value.boolValue : false;
|
|
}
|
|
|
|
export function isBoolValue(value: AnyValue | undefined): value is { boolValue: boolean } {
|
|
if (!value) return false;
|
|
|
|
return typeof value.boolValue === "boolean";
|
|
}
|
|
|
|
export function isStringValue(value: AnyValue | undefined): value is { stringValue: string } {
|
|
if (!value) return false;
|
|
|
|
return typeof value.stringValue === "string";
|
|
}
|
|
|
|
function isIntValue(value: AnyValue | undefined): value is { intValue: bigint } {
|
|
if (!value) return false;
|
|
|
|
return typeof value.intValue === "number" || typeof value.intValue === "bigint";
|
|
}
|
|
|
|
function isDoubleValue(value: AnyValue | undefined): value is { doubleValue: number } {
|
|
if (!value) return false;
|
|
|
|
return typeof value.doubleValue === "number";
|
|
}
|
|
|
|
function isBytesValue(value: AnyValue | undefined): value is { bytesValue: Buffer } {
|
|
if (!value) return false;
|
|
|
|
return Buffer.isBuffer(value.bytesValue);
|
|
}
|
|
|
|
function isArrayValue(
|
|
value: AnyValue | undefined
|
|
): value is { arrayValue: { values: AnyValue[] } } {
|
|
if (!value) return false;
|
|
|
|
return value.arrayValue != null && Array.isArray(value.arrayValue.values);
|
|
}
|
|
|
|
/**
|
|
* Serialize an OTEL array value into a JSON string.
|
|
* For arrays of strings, produces a JSON array: `["item1","item2"]`
|
|
* For mixed types, extracts primitives and serializes.
|
|
*/
|
|
function serializeArrayValue(values: AnyValue[]): string {
|
|
const items = values.map((v) => {
|
|
if (isStringValue(v)) return v.stringValue;
|
|
if (isIntValue(v)) return Number(v.intValue);
|
|
if (isDoubleValue(v)) return v.doubleValue;
|
|
if (isBoolValue(v)) return v.boolValue;
|
|
return null;
|
|
});
|
|
|
|
return JSON.stringify(items);
|
|
}
|
|
|
|
function binaryToHex(buffer: Buffer | string): string;
|
|
function binaryToHex(buffer: Buffer | string | undefined): string | undefined;
|
|
function binaryToHex(buffer: Buffer | string | undefined): string | undefined {
|
|
if (!buffer) return undefined;
|
|
if (typeof buffer === "string") return buffer;
|
|
|
|
return Buffer.from(Array.from(buffer)).toString("hex");
|
|
}
|
|
|
|
function truncateAttributes(
|
|
attributes: Record<string, string | number | boolean | undefined> | undefined,
|
|
maximumLength: number = 1024
|
|
): Record<string, string | number | boolean | undefined> | undefined {
|
|
if (!attributes) return undefined;
|
|
|
|
const truncatedAttributes: Record<string, string | number | boolean | undefined> = {};
|
|
|
|
for (const [key, value] of Object.entries(attributes)) {
|
|
if (!key) continue;
|
|
|
|
if (typeof value === "string") {
|
|
truncatedAttributes[key] = truncateAndDetectUnpairedSurrogate(value, maximumLength);
|
|
} else {
|
|
truncatedAttributes[key] = value;
|
|
}
|
|
}
|
|
|
|
return truncatedAttributes;
|
|
}
|
|
|
|
function truncateAndDetectUnpairedSurrogate(str: string, maximumLength: number): string {
|
|
const truncatedString = smartTruncateString(str, maximumLength);
|
|
|
|
if (hasUnpairedSurrogateAtEnd(truncatedString)) {
|
|
return smartTruncateString(truncatedString, [...truncatedString].length - 1);
|
|
}
|
|
|
|
return truncatedString;
|
|
}
|
|
|
|
const ASCII_ONLY_REGEX = /^[\p{ASCII}]*$/u;
|
|
|
|
function smartTruncateString(str: string, maximumLength: number): string {
|
|
if (!str) return "";
|
|
if (str.length <= maximumLength) return str;
|
|
|
|
const checkLength = Math.min(str.length, maximumLength * 2 + 2);
|
|
|
|
if (ASCII_ONLY_REGEX.test(str.slice(0, checkLength))) {
|
|
return str.slice(0, maximumLength);
|
|
}
|
|
|
|
return [...str.slice(0, checkLength)].slice(0, maximumLength).join("");
|
|
}
|
|
|
|
function hasUnpairedSurrogateAtEnd(str: string): boolean {
|
|
if (str.length === 0) return false;
|
|
|
|
const lastCode = str.charCodeAt(str.length - 1);
|
|
|
|
// Check if last character is an unpaired high surrogate
|
|
if (lastCode >= 0xd800 && lastCode <= 0xdbff) {
|
|
return true; // High surrogate at end = unpaired
|
|
}
|
|
|
|
// Check if last character is an unpaired low surrogate
|
|
if (lastCode >= 0xdc00 && lastCode <= 0xdfff) {
|
|
// Low surrogate is only valid if preceded by high surrogate
|
|
if (str.length === 1) return true; // Single low surrogate
|
|
|
|
const secondLastCode = str.charCodeAt(str.length - 2);
|
|
if (secondLastCode < 0xd800 || secondLastCode > 0xdbff) {
|
|
return true; // Low surrogate not preceded by high surrogate
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|