autotel
Version:
Write Once, Observe Anywhere
612 lines (606 loc) • 21.9 kB
JavaScript
export { createDrainPipeline } from './chunk-KFOHQK7X.js';
export { getCurrentWorkflowContext, isInWorkflow, traceStep, traceWorkflow } from './chunk-YN7USLHW.js';
export { attrs, autoRedactPII, dbClient, httpClient, httpServer, identify, mergeAttrs, mergeServiceResource, request, safeSetAttributes, setDevice, setError, setException, setSession, setUser, validateAttribute } from './chunk-ER43K7ES.js';
export { httpRequestHeaderAttribute, httpResponseHeaderAttribute } from './chunk-7552UTQW.js';
export { HTTPAttributes, ServiceAttributes, URLAttributes } from './chunk-4A53YIAX.js';
export { parseError } from './chunk-J7VGRIAJ.js';
export { traceConsumer, traceProducer } from './chunk-QC5MNKVF.js';
export { BusinessBaggage, createSafeBaggageSchema } from './chunk-4IFSYQVX.js';
import { resetMetrics } from './chunk-7SAWIN74.js';
export { Metric, getMetrics, resetMetrics } from './chunk-7SAWIN74.js';
import './chunk-5ZN622AO.js';
export { createCounter, createHistogram, createObservableGauge, createUpDownCounter, getMeter } from './chunk-TQ5UWA7S.js';
export { traceDB, traceHTTP, traceLLM, traceMessaging } from './chunk-U54FTVFH.js';
import { getEventQueue, resetEventQueue } from './chunk-HPUGKUMZ.js';
export { ctx, getEventQueue, instrument, span, trace, track, withBaggage, withNewContext, withTracing } from './chunk-HPUGKUMZ.js';
export { createDeterministicTraceId, enrichWithTraceContext, finalizeSpan, flattenMetadata, getActiveContext, getActiveSpan, getTraceContext, getTracer, isTracing, resolveTraceUrl, runWithSpan } from './chunk-B3ZHLLMP.js';
import { resetEvents } from './chunk-BJ2XPN77.js';
export { Event, getEvents, resetEvents } from './chunk-BJ2XPN77.js';
import './chunk-LITNXTTT.js';
import './chunk-BZHG5IZ4.js';
export { getOperationContext, runInOperationContext } from './chunk-WD4RP6IV.js';
export { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage } from './chunk-S4OFEXLA.js';
import { createTraceContext } from './chunk-BBBWDIYQ.js';
export { defineBaggageSchema } from './chunk-BBBWDIYQ.js';
import { getLogger, getSdk, _closeEmbeddedDevtools } from './chunk-W35FVJBC.js';
export { BaggageSpanProcessor, createStringRedactor, init, isLoggerLocked, lockLogger } from './chunk-W35FVJBC.js';
import './chunk-3SDILILG.js';
import './chunk-A4E5AQFK.js';
export { FilteringSpanProcessor } from './chunk-WGWSHJ2N.js';
export { NORMALIZER_PATTERNS, NORMALIZER_PRESETS, SpanNameNormalizingProcessor } from './chunk-GYR5K654.js';
export { AttributeRedactingProcessor, REDACTOR_PATTERNS, REDACTOR_PRESETS, createAttributeRedactor, createRedactedSpan } from './chunk-TDNKIHKT.js';
import './chunk-6UQRVUN3.js';
export { formatDuration } from './chunk-3QXBFGKP.js';
import './chunk-33WTKH7X.js';
export { AUTOTEL_SAMPLING_TAIL_EVALUATED, AUTOTEL_SAMPLING_TAIL_KEEP, AdaptiveSampler, AlwaysSampler, NeverSampler, RandomSampler, UserIdSampler, createLinkFromHeaders, extractLinksFromBatch, resolveSamplingPreset, samplingPresets } from './chunk-DPSA4QLA.js';
import './chunk-55ER2KD5.js';
import './chunk-J5QENANM.js';
export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider } from './chunk-HA2WBOGQ.js';
import './chunk-DGUM43GV.js';
import { AsyncLocalStorage } from 'async_hooks';
import { SpanStatusCode, trace } from '@opentelemetry/api';
export { ROOT_CONTEXT, SpanKind, SpanStatusCode, context, trace as otelTrace, propagation } from '@opentelemetry/api';
import { AggregationType } from '@opentelemetry/sdk-metrics';
// src/shutdown.ts
async function flush(options) {
const timeout = options?.timeout ?? 2e3;
const forShutdown = options?.forShutdown ?? false;
const doFlush = async () => {
const eventsQueue = getEventQueue();
if (eventsQueue) {
if (forShutdown) {
await eventsQueue.shutdown();
} else {
await eventsQueue.flush();
}
}
const sdk = getSdk();
if (sdk) {
try {
const sdkAny = sdk;
if (typeof sdkAny.getTracerProvider === "function") {
const tracerProvider = sdkAny.getTracerProvider();
if (tracerProvider && typeof tracerProvider.forceFlush === "function") {
await tracerProvider.forceFlush();
}
}
} catch {
}
}
};
let timeoutHandle;
try {
await Promise.race([
doFlush().finally(() => {
if (timeoutHandle) {
clearTimeout(timeoutHandle);
}
}),
new Promise((_, reject) => {
timeoutHandle = setTimeout(
() => reject(new Error("Flush timeout")),
timeout
);
timeoutHandle.unref();
})
]);
} catch (error) {
if (timeoutHandle) {
clearTimeout(timeoutHandle);
}
const logger = getLogger();
logger.error(
{
err: error instanceof Error ? error : new Error(String(error))
},
"[autotel] Flush error"
);
throw error;
}
}
async function shutdown() {
const logger = getLogger();
let shutdownError = null;
try {
await flush({ forShutdown: true });
} catch (error) {
const err = error instanceof Error ? error : new Error(String(error));
shutdownError = err;
logger.error(
{
err
},
"[autotel] Flush failed during shutdown, continuing cleanup"
);
}
try {
const sdk = getSdk();
if (sdk) {
await sdk.shutdown();
}
} catch (error) {
const err = error instanceof Error ? error : new Error(String(error));
const isConnectionRefused = typeof error === "object" && error !== null && "code" in error && error.code === "ECONNREFUSED";
if (!isConnectionRefused) {
if (!shutdownError) {
shutdownError = err;
}
logger.error({ err }, "[autotel] SDK shutdown failed");
}
} finally {
await _closeEmbeddedDevtools();
const eventsQueue = getEventQueue();
if (eventsQueue && typeof eventsQueue.cleanup === "function") {
eventsQueue.cleanup();
}
resetEvents();
resetMetrics();
resetEventQueue();
}
if (shutdownError) {
throw shutdownError;
}
}
function registerShutdownHooks() {
if (typeof process === "undefined") return;
const signals = ["SIGTERM", "SIGINT"];
let shuttingDown = false;
for (const signal of signals) {
process.on(signal, async () => {
if (shuttingDown) return;
shuttingDown = true;
if (process.env.NODE_ENV !== "test") {
getLogger().info(
{},
`[autotel] Received ${signal}, flushing telemetry...`
);
}
try {
await shutdown();
} catch (error) {
getLogger().error(
{
err: error instanceof Error ? error : void 0
},
"[autotel] Error during shutdown"
);
} finally {
process.exit(0);
}
});
}
}
registerShutdownHooks();
// src/flatten-attributes.ts
function toAttributeValue(value) {
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
return value;
}
if (Array.isArray(value)) {
if (value.every((v) => typeof v === "string") || value.every((v) => typeof v === "number") || value.every((v) => typeof v === "boolean")) {
return value;
}
try {
return JSON.stringify(value);
} catch {
return "<serialization-failed>";
}
}
if (value instanceof Date) {
return value.toISOString();
}
if (value instanceof Error) {
return value.message;
}
return void 0;
}
function flattenToAttributes(fields, prefix = "") {
const out = {};
const seen = /* @__PURE__ */ new WeakSet();
function flatten(obj, currentPrefix) {
for (const [key, value] of Object.entries(obj)) {
if (value == null) continue;
const nextKey = currentPrefix ? `${currentPrefix}.${key}` : key;
const attr = toAttributeValue(value);
if (attr !== void 0) {
out[nextKey] = attr;
continue;
}
if (typeof value === "object" && value.constructor === Object) {
if (seen.has(value)) {
out[nextKey] = "<circular-reference>";
continue;
}
seen.add(value);
flatten(value, nextKey);
continue;
}
try {
out[nextKey] = JSON.stringify(value);
} catch {
out[nextKey] = "<serialization-failed>";
}
}
}
flatten(fields, prefix);
return out;
}
// src/structured-error.ts
var internalKey = /* @__PURE__ */ Symbol.for("autotel.error.internal");
function createStructuredError(input) {
const error = new Error(input.message, {
cause: input.cause
});
error.name = input.name ?? "StructuredError";
if (input.why !== void 0) error.why = input.why;
if (input.fix !== void 0) error.fix = input.fix;
if (input.link !== void 0) error.link = input.link;
if (input.code !== void 0) error.code = input.code;
if (input.status !== void 0) error.status = input.status;
if (input.details !== void 0) error.details = input.details;
if (input.internal !== void 0) {
Object.defineProperty(error, internalKey, {
value: input.internal,
enumerable: false,
writable: false,
configurable: true
});
}
Object.defineProperty(error, "internal", {
get() {
return this[internalKey];
},
enumerable: false,
configurable: true
});
error.toString = () => {
const lines = [`${error.name}: ${error.message}`];
if (error.why) lines.push(` Why: ${error.why}`);
if (error.fix) lines.push(` Fix: ${error.fix}`);
if (error.link) lines.push(` Link: ${error.link}`);
if (error.code !== void 0) lines.push(` Code: ${error.code}`);
if (error.status !== void 0) lines.push(` Status: ${error.status}`);
if (error.cause) {
const cause = error.cause;
lines.push(` Caused by: ${cause.name}: ${cause.message}`);
}
return lines.join("\n");
};
return error;
}
function structuredErrorToJSON(error) {
const result = {
name: error.name,
message: error.message
};
if (error.status !== void 0) result.status = error.status;
if (error.why || error.fix || error.link) {
result.data = {
...error.why && { why: error.why },
...error.fix && { fix: error.fix },
...error.link && { link: error.link }
};
}
if (error.code !== void 0) result.code = error.code;
if (error.details) result.details = error.details;
if (error.cause instanceof Error) {
result.cause = { name: error.cause.name, message: error.cause.message };
}
return result;
}
function getStructuredErrorAttributes(error) {
const structured = error;
const attributes = {
"error.type": error.name || "Error",
"error.message": error.message
};
if (error.stack) attributes["error.stack"] = error.stack;
if (structured.why) attributes["error.why"] = structured.why;
if (structured.fix) attributes["error.fix"] = structured.fix;
if (structured.link) attributes["error.link"] = structured.link;
if (structured.code !== void 0) {
attributes["error.code"] = typeof structured.code === "string" ? structured.code : String(structured.code);
}
if (structured.status !== void 0) {
attributes["error.status"] = structured.status;
}
if (structured.details) {
Object.assign(
attributes,
flattenToAttributes(structured.details, "error.details")
);
}
return attributes;
}
function recordStructuredError(ctx2, error) {
ctx2.recordException(error);
ctx2.setStatus({
code: SpanStatusCode.ERROR,
message: error.message
});
ctx2.setAttributes(getStructuredErrorAttributes(error));
}
// src/request-logger.ts
var POST_EMIT_FORK_HINT = "For intentional background work tied to this request, use log.fork('label', fn) when available.";
function warnPostEmit(method, detail) {
console.warn(
`[autotel] ${method} called after the wide event was emitted \u2014 ${detail} This data will not appear in observability. ${POST_EMIT_FORK_HINT}`
);
}
function mergeInto(target, source) {
for (const key in source) {
const sourceVal = source[key];
if (sourceVal === void 0) continue;
const targetVal = target[key];
if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
mergeInto(
targetVal,
sourceVal
);
} else if (Array.isArray(targetVal) && Array.isArray(sourceVal)) {
target[key] = [...targetVal, ...sourceVal];
} else {
target[key] = sourceVal;
}
}
}
var requestContextStore = new AsyncLocalStorage();
function runWithRequestContext(ctx2, fn) {
return requestContextStore.run(ctx2, fn);
}
function resolveContext(ctx2) {
if (ctx2) return ctx2;
const stored = requestContextStore.getStore();
if (stored) return stored;
const span2 = trace.getActiveSpan();
if (!span2) {
throw new Error(
"[autotel] getRequestLogger() requires an active span or runWithRequestContext(). Wrap your handler with trace() or use runWithRequestContext()."
);
}
return createTraceContext(span2);
}
function getRequestLogger(ctx2, options) {
const activeContext = resolveContext(ctx2);
let contextState = {};
let emitted = false;
let lastSnapshot = null;
const addLogEvent = (level, message, fields) => {
const attrs2 = fields ? flattenToAttributes(fields) : void 0;
activeContext.addEvent(`log.${level}`, {
message,
...attrs2
});
};
const sealCheck = (method, keys) => {
if (emitted) {
warnPostEmit(
method,
`Keys dropped: ${keys.length ? keys.join(", ") : "(empty)"}.`
);
}
};
return {
set(fields) {
sealCheck("log.set()", Object.keys(fields));
if (emitted) return;
mergeInto(contextState, fields);
activeContext.setAttributes(flattenToAttributes(fields));
},
info(message, fields) {
const keys = fields ? ["message", ...Object.keys(fields).filter((k) => k !== "requestLogs")] : ["message"];
sealCheck("log.info()", keys);
if (emitted) return;
addLogEvent("info", message, fields);
if (fields) {
mergeInto(contextState, fields);
activeContext.setAttributes(flattenToAttributes(fields));
}
},
warn(message, fields) {
const keys = fields ? ["message", ...Object.keys(fields).filter((k) => k !== "requestLogs")] : ["message"];
sealCheck("log.warn()", keys);
if (emitted) return;
addLogEvent("warn", message, fields);
activeContext.setAttribute("autotel.log.level", "warn");
if (fields) {
mergeInto(contextState, fields);
activeContext.setAttributes(flattenToAttributes(fields));
}
},
error(error, fields) {
const keys = fields ? [...Object.keys(fields), "error"] : ["error"];
sealCheck("log.error()", keys);
if (emitted) return;
const err = typeof error === "string" ? new Error(error) : error;
recordStructuredError(activeContext, err);
addLogEvent("error", err.message, fields);
if (fields) {
mergeInto(contextState, fields);
activeContext.setAttributes(flattenToAttributes(fields));
}
activeContext.setAttribute("autotel.log.level", "error");
},
getContext() {
return { ...contextState };
},
emitNow(overrides) {
if (emitted) {
warnPostEmit("log.emitNow()", "Ignoring duplicate emit.");
return lastSnapshot;
}
const mergedContext = {
...contextState,
...overrides ?? {}
};
const flattened = flattenToAttributes(mergedContext);
activeContext.setAttributes(flattened);
const snapshot = {
timestamp: (/* @__PURE__ */ new Date()).toISOString(),
traceId: activeContext.traceId,
spanId: activeContext.spanId,
correlationId: activeContext.correlationId,
context: mergedContext
};
activeContext.addEvent("log.emit.manual", {
...flattened
});
if (options?.onEmit) {
Promise.resolve(options.onEmit(snapshot)).catch((error) => {
console.warn("[autotel] request logger onEmit failed:", error);
});
}
emitted = true;
lastSnapshot = snapshot;
return snapshot;
},
fork(label, fn) {
const parentRequestId = activeContext.correlationId;
if (typeof parentRequestId !== "string" || parentRequestId.length === 0) {
throw new Error(
"[autotel] log.fork() requires the parent logger to have a correlationId. Ensure the request was created by autotel middleware."
);
}
const tracer = trace.getTracer("autotel.request-logger");
void tracer.startActiveSpan(`request.fork:${label}`, (childSpan) => {
const childContext = {
...createTraceContext(childSpan),
correlationId: crypto.randomUUID()
};
requestContextStore.run(childContext, () => {
const childLog = getRequestLogger(childContext);
childLog.set({
operation: label,
_parentCorrelationId: parentRequestId
});
void Promise.resolve().then(() => fn()).then(() => {
childLog.emitNow();
}).catch((err) => {
const error = err instanceof Error ? err : new Error(String(err));
childLog.error(error);
childLog.emitNow();
}).finally(() => {
childSpan.end();
});
});
});
}
};
}
var GEN_AI_DURATION_BUCKETS_SECONDS = Object.freeze(
[0.01, 0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 20, 30, 60, 120, 300]
);
var GEN_AI_TOKEN_USAGE_BUCKETS = Object.freeze([
1,
4,
16,
64,
256,
1024,
4096,
16384,
65536,
262144,
1048576,
4194304
]);
var GEN_AI_COST_USD_BUCKETS = Object.freeze([
1e-5,
1e-4,
1e-3,
5e-3,
0.01,
0.05,
0.1,
0.5,
1,
5,
10,
50
]);
function llmHistogramAdvice(kind) {
const boundaries = kind === "duration" ? GEN_AI_DURATION_BUCKETS_SECONDS : kind === "tokens" ? GEN_AI_TOKEN_USAGE_BUCKETS : GEN_AI_COST_USD_BUCKETS;
return { advice: { explicitBucketBoundaries: [...boundaries] } };
}
function genAiMetricViews(extra = []) {
const defaults = [
{ instrumentName: "gen_ai.client.operation.duration", kind: "duration" },
{ instrumentName: "gen_ai.client.token.usage", kind: "tokens" },
// Autotel-emitted cost metric. No-op if you don't emit it.
{ instrumentName: "gen_ai.client.cost.usd", kind: "cost" }
];
return [...defaults, ...extra].map(
({ instrumentName, kind }) => ({
instrumentName,
aggregation: {
type: AggregationType.EXPLICIT_BUCKET_HISTOGRAM,
options: {
boundaries: kind === "duration" ? [...GEN_AI_DURATION_BUCKETS_SECONDS] : kind === "tokens" ? [...GEN_AI_TOKEN_USAGE_BUCKETS] : [...GEN_AI_COST_USD_BUCKETS]
}
}
})
);
}
// src/gen-ai-events.ts
function recordPromptSent(ctx2, event = {}) {
ctx2.addEvent("gen_ai.prompt.sent", buildPromptSentAttrs(event));
}
function recordResponseReceived(ctx2, event = {}) {
ctx2.addEvent("gen_ai.response.received", buildResponseAttrs(event));
}
function recordRetry(ctx2, event) {
ctx2.addEvent("gen_ai.retry", buildRetryAttrs(event));
}
function recordToolCall(ctx2, event) {
ctx2.addEvent("gen_ai.tool.call", buildToolCallAttrs(event));
}
function recordStreamFirstToken(ctx2, event = {}) {
ctx2.addEvent("gen_ai.stream.first_token", buildStreamFirstTokenAttrs(event));
}
function buildPromptSentAttrs(event) {
const attrs2 = {};
if (event.model) attrs2["gen_ai.request.model"] = event.model;
if (event.promptTokens !== void 0)
attrs2["gen_ai.usage.input_tokens"] = event.promptTokens;
if (event.messageCount !== void 0)
attrs2["gen_ai.request.message_count"] = event.messageCount;
if (event.operation) attrs2["gen_ai.operation.name"] = event.operation;
return attrs2;
}
function buildResponseAttrs(event) {
const attrs2 = {};
if (event.model) attrs2["gen_ai.response.model"] = event.model;
if (event.promptTokens !== void 0)
attrs2["gen_ai.usage.input_tokens"] = event.promptTokens;
if (event.completionTokens !== void 0)
attrs2["gen_ai.usage.output_tokens"] = event.completionTokens;
if (event.totalTokens !== void 0)
attrs2["gen_ai.usage.total_tokens"] = event.totalTokens;
if (event.finishReasons && event.finishReasons.length > 0) {
attrs2["gen_ai.response.finish_reasons"] = event.finishReasons.join(",");
}
return attrs2;
}
function buildRetryAttrs(event) {
const attrs2 = { "retry.attempt": event.attempt };
if (event.reason) attrs2["retry.reason"] = event.reason;
if (event.delayMs !== void 0) attrs2["retry.delay_ms"] = event.delayMs;
if (event.statusCode !== void 0)
attrs2["http.response.status_code"] = event.statusCode;
return attrs2;
}
function buildToolCallAttrs(event) {
const attrs2 = { "gen_ai.tool.name": event.toolName };
if (event.toolCallId) attrs2["gen_ai.tool.call.id"] = event.toolCallId;
if (event.arguments) attrs2["gen_ai.tool.arguments"] = event.arguments;
return attrs2;
}
function buildStreamFirstTokenAttrs(event) {
const attrs2 = {};
if (event.tokensSoFar !== void 0)
attrs2["gen_ai.stream.tokens_so_far"] = event.tokensSoFar;
return attrs2;
}
export { GEN_AI_COST_USD_BUCKETS, GEN_AI_DURATION_BUCKETS_SECONDS, GEN_AI_TOKEN_USAGE_BUCKETS, createStructuredError, flattenToAttributes, flush, genAiMetricViews, getRequestLogger, getStructuredErrorAttributes, llmHistogramAdvice, recordPromptSent, recordResponseReceived, recordRetry, recordStreamFirstToken, recordStructuredError, recordToolCall, runWithRequestContext, shutdown, structuredErrorToJSON, toAttributeValue };
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map