@latitude-data/telemetry 1.0.4 → 1.1.0

package/dist/index.cjs

@@ -4,6 +4,7 @@ var zod = require('zod');
 var otel = require('@opentelemetry/api');
 var semanticConventions = require('@opentelemetry/semantic-conventions');
 var incubating = require('@opentelemetry/semantic-conventions/incubating');
+var uuid = require('uuid');
 var baggageSpanProcessor = require('@opentelemetry/baggage-span-processor');
 var contextAsyncHooks = require('@opentelemetry/context-async-hooks');
 var core = require('@opentelemetry/core');
@@ -94,7 +95,7 @@ const DEFAULT_REDACT_SPAN_PROCESSOR = () => new RedactSpanProcessor({
     attributes: [
         /^.*auth.*$/i,
         /^.*authorization.*$/i,
-        /^(?!ai\.).*usage.*$/i,
+        /^(?!gen_ai\.).*usage.*$/i,
         /^(?!gen_ai\.).*token.*$/i,
         /^.*secret.*$/i,
         /^.*key.*$/i,
@@ -208,6 +209,7 @@ const compositeEvaluationConfiguration = baseEvaluationConfiguration.extend({
     evaluationUuids: zod.z.array(zod.z.string()),
     minThreshold: zod.z.number().optional(), // Threshold percentage
     maxThreshold: zod.z.number().optional(), // Threshold percentage
+    defaultTarget: zod.z.boolean().optional(), // Default for optimizations and distillations
 });
 const compositeEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
     results: zod.z.record(zod.z.string(), // Evaluation uuid
@@ -275,7 +277,7 @@ const CompositeEvaluationSpecification = {
 };
 
 const humanEvaluationConfiguration = baseEvaluationConfiguration.extend({
-    enableControls: zod.z.boolean().optional(),
+    enableControls: zod.z.boolean().optional(), // UI annotation controls
     criteria: zod.z.string().optional(),
 });
 const humanEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
@@ -803,6 +805,9 @@ var SpanType;
     SpanType["Http"] = "http";
     SpanType["Unknown"] = "unknown";
     SpanType["Prompt"] = "prompt";
+    SpanType["Chat"] = "chat";
+    SpanType["External"] = "external";
+    SpanType["UnresolvedExternal"] = "unresolved_external";
     SpanType["Step"] = "step";
 })(SpanType || (SpanType = {}));
 const SPAN_SPECIFICATIONS = {
@@ -854,6 +859,24 @@ const SPAN_SPECIFICATIONS = {
         isGenAI: false,
         isHidden: false,
     },
+    [SpanType.Chat]: {
+        name: 'Chat',
+        description: 'A chat continuation span',
+        isGenAI: false,
+        isHidden: false,
+    },
+    [SpanType.External]: {
+        name: 'External',
+        description: 'An external capture span',
+        isGenAI: false,
+        isHidden: false,
+    },
+    [SpanType.UnresolvedExternal]: {
+        name: 'Unresolved External',
+        description: 'An external span that needs path resolution before storage',
+        isGenAI: false,
+        isHidden: true,
+    },
     [SpanType.Step]: {
         name: 'Step',
         description: 'A step span',
@@ -907,7 +930,16 @@ var InstrumentationScope;
 /* Note: non-standard OpenTelemetry semantic conventions used in Latitude */
 const ATTR_LATITUDE = 'latitude';
 const ATTR_LATITUDE_TYPE = `${ATTR_LATITUDE}.type`;
+const ATTR_LATITUDE_DOCUMENT_UUID = `${ATTR_LATITUDE}.document_uuid`;
+const ATTR_LATITUDE_PROMPT_PATH = `${ATTR_LATITUDE}.prompt_path`;
+const ATTR_LATITUDE_COMMIT_UUID = `${ATTR_LATITUDE}.commit_uuid`;
+const ATTR_LATITUDE_DOCUMENT_LOG_UUID = `${ATTR_LATITUDE}.document_log_uuid`;
+const ATTR_LATITUDE_PROJECT_ID = `${ATTR_LATITUDE}.project_id`;
+const ATTR_LATITUDE_EXPERIMENT_UUID = `${ATTR_LATITUDE}.experiment_uuid`;
+const ATTR_LATITUDE_SOURCE = `${ATTR_LATITUDE}.source`;
+const ATTR_LATITUDE_EXTERNAL_ID = `${ATTR_LATITUDE}.external_id`;
 const ATTR_LATITUDE_TEST_DEPLOYMENT_ID = `${ATTR_LATITUDE}.test_deployment_id`;
+const ATTR_LATITUDE_PREVIOUS_TRACE_ID = `${ATTR_LATITUDE}.previous_trace_id`;
 const GEN_AI_TOOL_TYPE_VALUE_FUNCTION = 'function';
 const ATTR_GEN_AI_TOOL_CALL_ARGUMENTS = 'gen_ai.tool.call.arguments';
 const ATTR_GEN_AI_TOOL_RESULT_VALUE = 'gen_ai.tool.result.value';
@@ -1064,6 +1096,7 @@ var DocumentTriggerParameters;
     DocumentTriggerParameters["Body"] = "body";
     DocumentTriggerParameters["Attachments"] = "attachments";
 })(DocumentTriggerParameters || (DocumentTriggerParameters = {}));
+const DOCUMENT_PATH_REGEXP = /^([\w-]+\/)*([\w-.])+$/;
 
 class ManualInstrumentation {
     enabled;
@@ -1082,7 +1115,33 @@ class ManualInstrumentation {
         this.enabled = false;
     }
     resume(ctx) {
-        return otel.propagation.extract(otel__namespace.ROOT_CONTEXT, ctx);
+        const parts = ctx.traceparent.split('-');
+        if (parts.length !== 4) {
+            return otel__namespace.ROOT_CONTEXT;
+        }
+        const [, traceId, spanId, flags] = parts;
+        if (!traceId || !spanId) {
+            return otel__namespace.ROOT_CONTEXT;
+        }
+        const spanContext = {
+            traceId,
+            spanId,
+            traceFlags: parseInt(flags ?? '01', 16),
+            isRemote: true,
+        };
+        let context = otel.trace.setSpanContext(otel__namespace.ROOT_CONTEXT, spanContext);
+        if (ctx.baggage) {
+            const baggageEntries = {};
+            for (const pair of ctx.baggage.split(',')) {
+                const [key, value] = pair.split('=');
+                if (key && value) {
+                    baggageEntries[key] = { value: decodeURIComponent(value) };
+                }
+            }
+            const baggage = otel.propagation.createBaggage(baggageEntries);
+            context = otel.propagation.setBaggage(context, baggage);
+        }
+        return context;
     }
     capitalize(str) {
         if (str.length === 0)
@@ -1389,7 +1448,7 @@ class ManualInstrumentation {
     completion(ctx, options) {
         const start = options;
         const configuration = {
-            ...start.configuration,
+            ...(start.configuration ?? {}),
             model: start.model,
         };
         let jsonConfiguration = '';
@@ -1400,14 +1459,15 @@ class ManualInstrumentation {
             jsonConfiguration = '{}';
         }
         const attrConfiguration = this.attribifyConfiguration('input', configuration);
+        const input = start.input ?? [];
         let jsonInput = '';
         try {
-            jsonInput = JSON.stringify(start.input);
+            jsonInput = JSON.stringify(input);
         }
         catch (error) {
             jsonInput = '[]';
         }
-        const attrInput = this.attribifyMessages('input', start.input);
+        const attrInput = this.attribifyMessages('input', input);
         const span = this.span(ctx, start.name || `${start.provider} / ${start.model}`, SpanType.Completion, {
             attributes: {
                 [incubating.ATTR_GEN_AI_SYSTEM]: start.provider,
@@ -1416,37 +1476,45 @@ class ManualInstrumentation {
                 [ATTR_GEN_AI_REQUEST_MESSAGES]: jsonInput,
                 ...attrInput,
                 ...(start.attributes || {}),
-                ['latitude.commitUuid']: start.versionUuid,
-                ['latitude.documentUuid']: start.promptUuid,
-                ['latitude.experimentUuid']: start.experimentUuid,
+                [ATTR_LATITUDE_COMMIT_UUID]: start.versionUuid,
+                [ATTR_LATITUDE_DOCUMENT_UUID]: start.promptUuid,
+                [ATTR_LATITUDE_EXPERIMENT_UUID]: start.experimentUuid,
             },
         });
         return {
             context: span.context,
             end: (options) => {
-                const end = options;
+                const end = options ?? {};
+                const output = end.output ?? [];
                 let jsonOutput = '';
                 try {
-                    jsonOutput = JSON.stringify(end.output);
+                    jsonOutput = JSON.stringify(output);
                 }
                 catch (error) {
                     jsonOutput = '[]';
                 }
-                const attrOutput = this.attribifyMessages('output', end.output);
-                const inputTokens = end.tokens.prompt + end.tokens.cached;
-                const outputTokens = end.tokens.reasoning + end.tokens.completion;
+                const attrOutput = this.attribifyMessages('output', output);
+                const tokens = {
+                    prompt: end.tokens?.prompt ?? 0,
+                    cached: end.tokens?.cached ?? 0,
+                    reasoning: end.tokens?.reasoning ?? 0,
+                    completion: end.tokens?.completion ?? 0,
+                };
+                const inputTokens = tokens.prompt + tokens.cached;
+                const outputTokens = tokens.reasoning + tokens.completion;
+                const finishReason = end.finishReason ?? '';
                 span.end({
                     attributes: {
                         [ATTR_GEN_AI_RESPONSE_MESSAGES]: jsonOutput,
                         ...attrOutput,
                         [incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS]: inputTokens,
-                        [ATTR_GEN_AI_USAGE_PROMPT_TOKENS]: end.tokens.prompt,
-                        [ATTR_GEN_AI_USAGE_CACHED_TOKENS]: end.tokens.cached,
-                        [ATTR_GEN_AI_USAGE_REASONING_TOKENS]: end.tokens.reasoning,
-                        [ATTR_GEN_AI_USAGE_COMPLETION_TOKENS]: end.tokens.completion,
+                        [ATTR_GEN_AI_USAGE_PROMPT_TOKENS]: tokens.prompt,
+                        [ATTR_GEN_AI_USAGE_CACHED_TOKENS]: tokens.cached,
+                        [ATTR_GEN_AI_USAGE_REASONING_TOKENS]: tokens.reasoning,
+                        [ATTR_GEN_AI_USAGE_COMPLETION_TOKENS]: tokens.completion,
                         [incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: outputTokens,
                         [incubating.ATTR_GEN_AI_RESPONSE_MODEL]: start.model,
-                        [incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS]: [end.finishReason],
+                        [incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS]: [finishReason],
                         ...(end.attributes || {}),
                     },
                 });
@@ -1544,16 +1612,18 @@ class ManualInstrumentation {
         const attributes = {
             [ATTR_GEN_AI_REQUEST_TEMPLATE]: template,
             [ATTR_GEN_AI_REQUEST_PARAMETERS]: jsonParameters,
-            ['latitude.commitUuid']: versionUuid || HEAD_COMMIT,
-            ['latitude.documentUuid']: promptUuid,
-            ['latitude.projectId']: projectId,
-            ...(documentLogUuid && { ['latitude.documentLogUuid']: documentLogUuid }),
-            ...(experimentUuid && { ['latitude.experimentUuid']: experimentUuid }),
+            [ATTR_LATITUDE_COMMIT_UUID]: versionUuid || HEAD_COMMIT,
+            [ATTR_LATITUDE_DOCUMENT_UUID]: promptUuid,
+            [ATTR_LATITUDE_PROJECT_ID]: projectId,
+            [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: documentLogUuid,
+            ...(experimentUuid && {
+                [ATTR_LATITUDE_EXPERIMENT_UUID]: experimentUuid,
+            }),
             ...(testDeploymentId && {
                 [ATTR_LATITUDE_TEST_DEPLOYMENT_ID]: testDeploymentId,
             }),
-            ...(externalId && { ['latitude.externalId']: externalId }),
-            ...(source && { ['latitude.source']: source }),
+            ...(externalId && { [ATTR_LATITUDE_EXTERNAL_ID]: externalId }),
+            ...(source && { [ATTR_LATITUDE_SOURCE]: source }),
             ...(rest.attributes || {}),
         };
         return this.span(ctx, name || `prompt-${promptUuid}`, SpanType.Prompt, {
@@ -1563,24 +1633,58 @@ class ManualInstrumentation {
     step(ctx, options) {
         return this.span(ctx, 'step', SpanType.Step, options);
     }
+    chat(ctx, { documentLogUuid, previousTraceId, source, name, ...rest }) {
+        const attributes = {
+            [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: documentLogUuid,
+            [ATTR_LATITUDE_PREVIOUS_TRACE_ID]: previousTraceId,
+            ...(source && { [ATTR_LATITUDE_SOURCE]: source }),
+            ...(rest.attributes || {}),
+        };
+        return this.span(ctx, name || 'chat', SpanType.Chat, { attributes });
+    }
+    external(ctx, { promptUuid, documentLogUuid, source, versionUuid, externalId, name, ...rest }) {
+        const attributes = {
+            [ATTR_LATITUDE_DOCUMENT_UUID]: promptUuid,
+            [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: documentLogUuid,
+            [ATTR_LATITUDE_SOURCE]: source ?? LogSources.API,
+            ...(versionUuid && { [ATTR_LATITUDE_COMMIT_UUID]: versionUuid }),
+            ...(externalId && { [ATTR_LATITUDE_EXTERNAL_ID]: externalId }),
+            ...(rest.attributes || {}),
+        };
+        return this.span(ctx, name || `external-${promptUuid}`, SpanType.External, {
+            attributes,
+        });
+    }
+    unresolvedExternal(ctx, { path, projectId, versionUuid, conversationUuid, name, ...rest }) {
+        const attributes = {
+            [ATTR_LATITUDE_PROMPT_PATH]: path,
+            [ATTR_LATITUDE_PROJECT_ID]: projectId,
+            ...(versionUuid && { [ATTR_LATITUDE_COMMIT_UUID]: versionUuid }),
+            ...(conversationUuid && {
+                [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: conversationUuid,
+            }),
+            ...(rest.attributes || {}),
+        };
+        return this.span(ctx, name || `capture-${path}`, SpanType.UnresolvedExternal, { attributes });
+    }
 }
 
 class LatitudeInstrumentation {
     options;
-    telemetry;
+    manualTelemetry;
     constructor(tracer, options) {
-        this.telemetry = new ManualInstrumentation(tracer);
+        this.manualTelemetry = new ManualInstrumentation(tracer);
         this.options = options;
     }
     isEnabled() {
-        return this.telemetry.isEnabled();
+        return this.manualTelemetry.isEnabled();
     }
     enable() {
         this.options.module.instrument(this);
-        this.telemetry.enable();
+        this.manualTelemetry.enable();
     }
     disable() {
-        this.telemetry.disable();
+        this.manualTelemetry.disable();
         this.options.module.uninstrument();
     }
     countTokens(messages) {
@@ -1604,7 +1708,8 @@ class LatitudeInstrumentation {
     }
     async wrapRenderChain(fn, ...args) {
         const { prompt, parameters } = args[0];
-        const $prompt = this.telemetry.prompt(otel.context.active(), {
+        const $prompt = this.manualTelemetry.prompt(otel.context.active(), {
+            documentLogUuid: uuid.v4(),
             versionUuid: prompt.versionUuid,
             promptUuid: prompt.uuid,
             template: prompt.content,
@@ -1622,7 +1727,7 @@ class LatitudeInstrumentation {
         return result;
     }
     async wrapRenderStep(fn, ...args) {
-        const $step = this.telemetry.step(otel.context.active());
+        const $step = this.manualTelemetry.step(otel.context.active());
         let result;
         try {
             result = await otel.context.with($step.context, async () => await fn(...args));
@@ -1640,7 +1745,7 @@ class LatitudeInstrumentation {
         }
         const { provider, config, messages } = args[0];
         const model = config.model || 'unknown';
-        const $completion = this.telemetry.completion(otel.context.active(), {
+        const $completion = this.manualTelemetry.completion(otel.context.active(), {
             name: `${provider} / ${model}`,
             provider: provider,
             model: model,
@@ -1674,7 +1779,7 @@ class LatitudeInstrumentation {
     }
     async wrapRenderTool(fn, ...args) {
         const { toolRequest } = args[0];
-        const $tool = this.telemetry.tool(otel.context.active(), {
+        const $tool = this.manualTelemetry.tool(otel.context.active(), {
             name: toolRequest.toolName,
             call: {
                 id: toolRequest.toolCallId,
@@ -1699,10 +1804,165 @@ class LatitudeInstrumentation {
     }
 }
 
+var LatitudeErrorCodes;
+(function (LatitudeErrorCodes) {
+    LatitudeErrorCodes["UnexpectedError"] = "UnexpectedError";
+    LatitudeErrorCodes["OverloadedError"] = "OverloadedError";
+    LatitudeErrorCodes["RateLimitError"] = "RateLimitError";
+    LatitudeErrorCodes["UnauthorizedError"] = "UnauthorizedError";
+    LatitudeErrorCodes["ForbiddenError"] = "ForbiddenError";
+    LatitudeErrorCodes["BadRequestError"] = "BadRequestError";
+    LatitudeErrorCodes["NotFoundError"] = "NotFoundError";
+    LatitudeErrorCodes["ConflictError"] = "ConflictError";
+    LatitudeErrorCodes["UnprocessableEntityError"] = "UnprocessableEntityError";
+    LatitudeErrorCodes["NotImplementedError"] = "NotImplementedError";
+    LatitudeErrorCodes["PaymentRequiredError"] = "PaymentRequiredError";
+    LatitudeErrorCodes["AbortedError"] = "AbortedError";
+})(LatitudeErrorCodes || (LatitudeErrorCodes = {}));
+// NOTE: If you add a new error code, please add it to the pg enum in models/runErrors.ts
+var RunErrorCodes;
+(function (RunErrorCodes) {
+    RunErrorCodes["AIProviderConfigError"] = "ai_provider_config_error";
+    RunErrorCodes["AIRunError"] = "ai_run_error";
+    RunErrorCodes["ChainCompileError"] = "chain_compile_error";
+    RunErrorCodes["DefaultProviderExceededQuota"] = "default_provider_exceeded_quota_error";
+    RunErrorCodes["DefaultProviderInvalidModel"] = "default_provider_invalid_model_error";
+    RunErrorCodes["DocumentConfigError"] = "document_config_error";
+    RunErrorCodes["ErrorGeneratingMockToolResult"] = "error_generating_mock_tool_result";
+    RunErrorCodes["FailedToWakeUpIntegrationError"] = "failed_to_wake_up_integration_error";
+    RunErrorCodes["InvalidResponseFormatError"] = "invalid_response_format_error";
+    RunErrorCodes["MaxStepCountExceededError"] = "max_step_count_exceeded_error";
+    RunErrorCodes["MissingProvider"] = "missing_provider_error";
+    RunErrorCodes["RateLimit"] = "rate_limit_error";
+    RunErrorCodes["Unknown"] = "unknown_error";
+    RunErrorCodes["UnsupportedProviderResponseTypeError"] = "unsupported_provider_response_type_error";
+    RunErrorCodes["PaymentRequiredError"] = "payment_required_error";
+    RunErrorCodes["AbortError"] = "abort_error";
+    // DEPRECATED, but do not delete
+    RunErrorCodes["EvaluationRunMissingProviderLogError"] = "ev_run_missing_provider_log_error";
+    RunErrorCodes["EvaluationRunMissingWorkspaceError"] = "ev_run_missing_workspace_error";
+    RunErrorCodes["EvaluationRunResponseJsonFormatError"] = "ev_run_response_json_format_error";
+    RunErrorCodes["EvaluationRunUnsupportedResultTypeError"] = "ev_run_unsupported_result_type_error";
+})(RunErrorCodes || (RunErrorCodes = {}));
+var ApiErrorCodes;
+(function (ApiErrorCodes) {
+    ApiErrorCodes["HTTPException"] = "http_exception";
+    ApiErrorCodes["InternalServerError"] = "internal_server_error";
+})(ApiErrorCodes || (ApiErrorCodes = {}));
+
+class LatitudeError extends Error {
+    statusCode = 500;
+    name = LatitudeErrorCodes.UnexpectedError;
+    headers = {};
+    details;
+    constructor(message, details, status, name) {
+        super(message);
+        this.details = details ?? {};
+        this.statusCode = status ?? this.statusCode;
+        this.name = name ?? this.constructor.name;
+    }
+    serialize() {
+        return {
+            name: this.name,
+            code: this.name,
+            status: this.statusCode,
+            message: this.message,
+            details: this.details,
+        };
+    }
+    static deserialize(json) {
+        return new LatitudeError(json.message, json.details, json.status, json.name);
+    }
+}
+class BadRequestError extends LatitudeError {
+    statusCode = 400;
+    name = LatitudeErrorCodes.BadRequestError;
+}
+
 const TRACES_URL = `${env.GATEWAY_BASE_URL}/api/v3/traces`;
 const SERVICE_NAME = process.env.npm_package_name || 'unknown';
 const SCOPE_VERSION = process.env.npm_package_version || 'unknown';
 const BACKGROUND = () => otel__namespace.ROOT_CONTEXT;
+class SpanFactory {
+    telemetry;
+    constructor(telemetry) {
+        this.telemetry = telemetry;
+    }
+    tool(options, ctx) {
+        return this.telemetry.tool(ctx ?? otel.context.active(), options);
+    }
+    completion(options, ctx) {
+        return this.telemetry.completion(ctx ?? otel.context.active(), options);
+    }
+    embedding(options, ctx) {
+        return this.telemetry.embedding(ctx ?? otel.context.active(), options);
+    }
+    retrieval(options, ctx) {
+        return this.telemetry.retrieval(ctx ?? otel.context.active(), options);
+    }
+    reranking(options, ctx) {
+        return this.telemetry.reranking(ctx ?? otel.context.active(), options);
+    }
+    http(options, ctx) {
+        return this.telemetry.http(ctx ?? otel.context.active(), options);
+    }
+    prompt(options, ctx) {
+        return this.telemetry.prompt(ctx ?? otel.context.active(), options);
+    }
+    step(options, ctx) {
+        return this.telemetry.step(ctx ?? otel.context.active(), options);
+    }
+    chat(options, ctx) {
+        return this.telemetry.chat(ctx ?? otel.context.active(), options);
+    }
+    external(options, ctx) {
+        return this.telemetry.external(ctx ?? otel.context.active(), options);
+    }
+}
+class ContextManager {
+    telemetry;
+    constructor(telemetry) {
+        this.telemetry = telemetry;
+    }
+    resume(ctx) {
+        return this.telemetry.resume(ctx);
+    }
+    active() {
+        return otel.context.active();
+    }
+}
+class InstrumentationManager {
+    instrumentations;
+    constructor(instrumentations) {
+        this.instrumentations = instrumentations;
+    }
+    enable() {
+        this.instrumentations.forEach((instrumentation) => {
+            if (!instrumentation.isEnabled())
+                instrumentation.enable();
+        });
+    }
+    disable() {
+        this.instrumentations.forEach((instrumentation) => {
+            if (instrumentation.isEnabled())
+                instrumentation.disable();
+        });
+    }
+}
+class TracerManager {
+    nodeProvider;
+    scopeVersion;
+    constructor(nodeProvider, scopeVersion) {
+        this.nodeProvider = nodeProvider;
+        this.scopeVersion = scopeVersion;
+    }
+    get(scope) {
+        return this.provider(scope).getTracer('');
+    }
+    provider(scope) {
+        return new ScopedTracerProvider(`${SCOPE_LATITUDE}.${scope}`, this.scopeVersion, this.nodeProvider);
+    }
+}
 class ScopedTracerProvider {
     scope;
     version;
@@ -1740,9 +2000,13 @@ exports.Instrumentation = void 0;
 })(exports.Instrumentation || (exports.Instrumentation = {}));
 class LatitudeTelemetry {
     options;
-    provider;
-    telemetry;
-    instrumentations;
+    nodeProvider;
+    manualInstrumentation;
+    instrumentationsList;
+    span;
+    context;
+    instrumentation;
+    tracer;
     constructor(apiKey, options) {
         this.options = options || {};
         if (!this.options.exporter) {
@@ -1756,63 +2020,61 @@ class LatitudeTelemetry {
                 new core.W3CBaggagePropagator(),
             ],
         }));
-        this.provider = new sdkTraceNode.NodeTracerProvider({
+        this.nodeProvider = new sdkTraceNode.NodeTracerProvider({
             resource: new resources.Resource({ [semanticConventions.ATTR_SERVICE_NAME]: SERVICE_NAME }),
         });
         // Note: important, must run before the exporter span processors
-        this.provider.addSpanProcessor(new baggageSpanProcessor.BaggageSpanProcessor(baggageSpanProcessor.ALLOW_ALL_BAGGAGE_KEYS));
+        this.nodeProvider.addSpanProcessor(new baggageSpanProcessor.BaggageSpanProcessor(baggageSpanProcessor.ALLOW_ALL_BAGGAGE_KEYS));
         if (this.options.processors) {
             this.options.processors.forEach((processor) => {
-                this.provider.addSpanProcessor(processor);
+                this.nodeProvider.addSpanProcessor(processor);
             });
         }
         else {
-            this.provider.addSpanProcessor(DEFAULT_REDACT_SPAN_PROCESSOR());
+            this.nodeProvider.addSpanProcessor(DEFAULT_REDACT_SPAN_PROCESSOR());
         }
         if (this.options.disableBatch) {
-            this.provider.addSpanProcessor(new sdkTraceNode.SimpleSpanProcessor(this.options.exporter));
+            this.nodeProvider.addSpanProcessor(new sdkTraceNode.SimpleSpanProcessor(this.options.exporter));
         }
         else {
-            this.provider.addSpanProcessor(new sdkTraceNode.BatchSpanProcessor(this.options.exporter));
+            this.nodeProvider.addSpanProcessor(new sdkTraceNode.BatchSpanProcessor(this.options.exporter));
         }
-        this.provider.register();
+        this.nodeProvider.register();
         process.on('SIGTERM', async () => this.shutdown);
         process.on('SIGINT', async () => this.shutdown);
-        this.telemetry = null;
-        this.instrumentations = [];
+        this.manualInstrumentation = null;
+        this.instrumentationsList = [];
+        this.tracer = new TracerManager(this.nodeProvider, SCOPE_VERSION);
         this.initInstrumentations();
-        this.instrument();
+        this.instrumentation = new InstrumentationManager(this.instrumentationsList);
+        this.instrumentation.enable();
+        this.span = new SpanFactory(this.manualInstrumentation);
+        this.context = new ContextManager(this.manualInstrumentation);
     }
     async flush() {
-        await this.provider.forceFlush();
+        await this.nodeProvider.forceFlush();
         await this.options.exporter.forceFlush?.();
     }
     async shutdown() {
         await this.flush();
-        await this.provider.shutdown();
+        await this.nodeProvider.shutdown();
         await this.options.exporter.shutdown?.();
     }
-    tracerProvider(instrumentation) {
-        return new ScopedTracerProvider(`${SCOPE_LATITUDE}.${instrumentation}`, SCOPE_VERSION, this.provider);
-    }
-    tracer(instrumentation) {
-        return this.tracerProvider(instrumentation).getTracer('');
-    }
     // TODO(tracing): auto instrument outgoing HTTP requests
     initInstrumentations() {
-        this.instrumentations = [];
-        const tracer = this.tracer(InstrumentationScope.Manual);
-        this.telemetry = new ManualInstrumentation(tracer);
-        this.instrumentations.push(this.telemetry);
+        this.instrumentationsList = [];
+        const tracer = this.tracer.get(InstrumentationScope.Manual);
+        this.manualInstrumentation = new ManualInstrumentation(tracer);
+        this.instrumentationsList.push(this.manualInstrumentation);
         const latitude = this.options.instrumentations?.latitude;
         if (latitude) {
-            const tracer = this.tracer(exports.Instrumentation.Latitude);
+            const tracer = this.tracer.get(exports.Instrumentation.Latitude);
             const instrumentation = new LatitudeInstrumentation(tracer, typeof latitude === 'object' ? latitude : { module: latitude });
-            this.instrumentations.push(instrumentation);
+            this.instrumentationsList.push(instrumentation);
         }
         const configureInstrumentation = (instrumentationType, InstrumentationConstructor, instrumentationOptions) => {
             const providerPkg = this.options.instrumentations?.[instrumentationType];
-            const provider = this.tracerProvider(instrumentationType);
+            const provider = this.tracer.provider(instrumentationType);
             const instrumentation$1 = new InstrumentationConstructor(instrumentationOptions); // prettier-ignore
             instrumentation$1.setTracerProvider(provider);
             if (providerPkg) {
@@ -1822,7 +2084,7 @@ class LatitudeTelemetry {
                 instrumentations: [instrumentation$1],
                 tracerProvider: provider,
             });
-            this.instrumentations.push(instrumentation$1);
+            this.instrumentationsList.push(instrumentation$1);
         };
         configureInstrumentation(exports.Instrumentation.Anthropic, instrumentationAnthropic.AnthropicInstrumentation); // prettier-ignore
         configureInstrumentation(exports.Instrumentation.AIPlatform, instrumentationVertexai.AIPlatformInstrumentation); // prettier-ignore
@@ -1834,44 +2096,23 @@ class LatitudeTelemetry {
         configureInstrumentation(exports.Instrumentation.TogetherAI, instrumentationTogether.TogetherInstrumentation, { enrichTokens: true }); // prettier-ignore
         configureInstrumentation(exports.Instrumentation.VertexAI, instrumentationVertexai.VertexAIInstrumentation); // prettier-ignore
     }
-    instrument() {
-        this.instrumentations.forEach((instrumentation) => {
-            if (!instrumentation.isEnabled())
-                instrumentation.enable();
-        });
-    }
-    uninstrument() {
-        this.instrumentations.forEach((instrumentation) => {
-            if (instrumentation.isEnabled())
-                instrumentation.disable();
-        });
-    }
-    resume(ctx) {
-        return this.telemetry.resume(ctx);
-    }
-    tool(ctx, options) {
-        return this.telemetry.tool(ctx, options);
-    }
-    completion(ctx, options) {
-        return this.telemetry.completion(ctx, options);
-    }
-    embedding(ctx, options) {
-        return this.telemetry.embedding(ctx, options);
-    }
-    retrieval(ctx, options) {
-        return this.telemetry.retrieval(ctx, options);
-    }
-    reranking(ctx, options) {
-        return this.telemetry.reranking(ctx, options);
-    }
-    http(ctx, options) {
-        return this.telemetry.http(ctx, options);
-    }
-    prompt(ctx, options) {
-        return this.telemetry.prompt(ctx, options);
-    }
-    step(ctx, options) {
-        return this.telemetry.step(ctx, options);
+    async capture(options, fn) {
+        if (!DOCUMENT_PATH_REGEXP.test(options.path)) {
+            throw new BadRequestError("Invalid path, no spaces. Only letters, numbers, '.', '-' and '_'");
+        }
+        const span = this.manualInstrumentation.unresolvedExternal(otel__namespace.ROOT_CONTEXT, options);
+        try {
+            const result = await otel.context.with(span.context, () => fn(span.context));
+            span.end();
+            return result;
+        }
+        catch (error) {
+            span.fail(error);
+            throw error;
+        }
+        finally {
+            await this.flush();
+        }
     }
 }