@latitude-data/telemetry 1.1.1 → 2.0.0

package/dist/index.js

@@ -3,6 +3,7 @@ import { ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_
 import { ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
 import * as otel from '@opentelemetry/api';
 import { trace, propagation, context } from '@opentelemetry/api';
+import { Translator, Provider } from 'rosetta-ai';
 import { v4 } from 'uuid';
 import { BaggageSpanProcessor, ALLOW_ALL_BAGGAGE_KEYS } from '@opentelemetry/baggage-span-processor';
 import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
@@ -118,6 +119,23 @@ function GET_GATEWAY_BASE_URL() {
 }
 const env = { GATEWAY_BASE_URL: GET_GATEWAY_BASE_URL() };
 
+function toSnakeCase(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/[^A-Za-z0-9]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toLowerCase();
+}
+function toKebabCase(input) {
+    return input
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^A-Za-z0-9]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+
 var StreamEventTypes;
 (function (StreamEventTypes) {
     StreamEventTypes["Latitude"] = "latitude-event";
@@ -179,10 +197,24 @@ const expectedOutputConfiguration = z.object({
     parsingFormat: z.enum(['string', 'json']),
     fieldAccessor: z.string().optional(), // Field accessor to get the output from if it's a key-value format
 });
+const EVALUATION_TRIGGER_TARGETS = ['first', 'every', 'last'];
+const DEFAULT_LAST_INTERACTION_DEBOUNCE_SECONDS = 120;
+const LAST_INTERACTION_DEBOUNCE_MIN_SECONDS = 30;
+const LAST_INTERACTION_DEBOUNCE_MAX_SECONDS = 60 * 60 * 24; // 1 day
+const triggerConfiguration = z.object({
+    target: z.enum(EVALUATION_TRIGGER_TARGETS),
+    lastInteractionDebounce: z
+        .number()
+        .min(LAST_INTERACTION_DEBOUNCE_MIN_SECONDS)
+        .max(LAST_INTERACTION_DEBOUNCE_MAX_SECONDS)
+        .optional()
+        .default(DEFAULT_LAST_INTERACTION_DEBOUNCE_SECONDS),
+});
 const baseEvaluationConfiguration = z.object({
     reverseScale: z.boolean(), // If true, lower is better, otherwise, higher is better
     actualOutput: actualOutputConfiguration,
     expectedOutput: expectedOutputConfiguration.optional(),
+    trigger: triggerConfiguration.optional(),
 });
 const baseEvaluationResultMetadata = z.object({
     // configuration: Configuration snapshot is defined in every metric specification
@@ -571,14 +603,6 @@ z.object({
     evaluateLiveLogs: z.boolean().nullable().optional(),
 });
 
-var LegacyChainEventTypes;
-(function (LegacyChainEventTypes) {
-    LegacyChainEventTypes["Error"] = "chain-error";
-    LegacyChainEventTypes["Step"] = "chain-step";
-    LegacyChainEventTypes["Complete"] = "chain-complete";
-    LegacyChainEventTypes["StepComplete"] = "chain-step-complete";
-})(LegacyChainEventTypes || (LegacyChainEventTypes = {}));
-
 var ChainEventTypes;
 (function (ChainEventTypes) {
     ChainEventTypes["ChainCompleted"] = "chain-completed";
@@ -788,14 +812,6 @@ var RunSourceGroup;
     [RunSourceGroup.Playground]: [LogSources.Playground, LogSources.Experiment],
 });
 
-var MessageRole;
-(function (MessageRole) {
-    MessageRole["system"] = "system";
-    MessageRole["user"] = "user";
-    MessageRole["assistant"] = "assistant";
-    MessageRole["tool"] = "tool";
-})(MessageRole || (MessageRole = {}));
-
 var SpanKind;
 (function (SpanKind) {
     SpanKind["Internal"] = "internal";
@@ -920,12 +936,9 @@ const ATTRIBUTES = {
             _root: 'gen_ai.request',
             configuration: 'gen_ai.request.configuration',
             template: 'gen_ai.request.template',
-            parameters: 'gen_ai.request.parameters',
-            messages: 'gen_ai.request.messages'},
+            parameters: 'gen_ai.request.parameters'},
         response: {
-            _root: 'gen_ai.response',
-            messages: 'gen_ai.response.messages',
-        },
+            _root: 'gen_ai.response'},
         usage: {
             promptTokens: 'gen_ai.usage.prompt_tokens',
             cachedTokens: 'gen_ai.usage.cached_tokens',
@@ -960,10 +973,17 @@ const ATTRIBUTES = {
                 inputTokens: ATTR_GEN_AI_USAGE_INPUT_TOKENS,
                 outputTokens: ATTR_GEN_AI_USAGE_OUTPUT_TOKENS,
             },
+            systemInstructions: 'gen_ai.system.instructions', // Contains the PARTS of the "system message"
             tool: {
                 call: {
                     id: ATTR_GEN_AI_TOOL_CALL_ID,
                     arguments: 'gen_ai.tool.call.arguments'}},
+            input: {
+                messages: 'gen_ai.input.messages',
+            },
+            output: {
+                messages: 'gen_ai.output.messages',
+            },
             _deprecated: {
                 system: ATTR_GEN_AI_SYSTEM,
                 tool: {
@@ -973,40 +993,6 @@ const ATTRIBUTES = {
                         value: 'gen_ai.tool.result.value',
                         isError: 'gen_ai.tool.result.is_error',
                     },
-                },
-                prompt: {
-                    _root: 'gen_ai.prompt',
-                    index: (promptIndex) => ({
-                        role: `gen_ai.prompt.${promptIndex}.role`,
-                        content: `gen_ai.prompt.${promptIndex}.content`, // string or object
-                        toolCalls: (toolCallIndex) => ({
-                            id: `gen_ai.prompt.${promptIndex}.tool_calls.${toolCallIndex}.id`,
-                            name: `gen_ai.prompt.${promptIndex}.tool_calls.${toolCallIndex}.name`,
-                            arguments: `gen_ai.prompt.${promptIndex}.tool_calls.${toolCallIndex}.arguments`,
-                        }),
-                        tool: {
-                            callId: `gen_ai.prompt.${promptIndex}.tool_call_id`,
-                            toolName: `gen_ai.prompt.${promptIndex}.tool_name`,
-                            isError: `gen_ai.prompt.${promptIndex}.is_error`,
-                        },
-                    }),
-                },
-                completion: {
-                    _root: 'gen_ai.completion',
-                    index: (completionIndex) => ({
-                        role: `gen_ai.completion.${completionIndex}.role`,
-                        content: `gen_ai.completion.${completionIndex}.content`, // string or object
-                        toolCalls: (toolCallIndex) => ({
-                            id: `gen_ai.completion.${completionIndex}.tool_calls.${toolCallIndex}.id`,
-                            name: `gen_ai.completion.${completionIndex}.tool_calls.${toolCallIndex}.name`,
-                            arguments: `gen_ai.completion.${completionIndex}.tool_calls.${toolCallIndex}.arguments`,
-                        }),
-                        tool: {
-                            callId: `gen_ai.prompt.${completionIndex}.tool_call_id`,
-                            toolName: `gen_ai.prompt.${completionIndex}.tool_name`,
-                            isError: `gen_ai.prompt.${completionIndex}.is_error`,
-                        },
-                    }),
                 }},
         },
     }};
@@ -1134,11 +1120,25 @@ var Otlp;
 })(Otlp || (Otlp = {}));
 
 const MAX_SIMULATION_TURNS = 10;
+const globalGoalSourceSchema = z.object({
+    type: z.literal('global'),
+    value: z.string(),
+});
+const columnGoalSourceSchema = z.object({
+    type: z.literal('column'),
+    columnIndex: z.number(),
+});
+const simulatedUserGoalSourceSchema = z.discriminatedUnion('type', [
+    globalGoalSourceSchema,
+    columnGoalSourceSchema,
+]);
 const SimulationSettingsSchema = z.object({
     simulateToolResponses: z.boolean().optional(),
     simulatedTools: z.array(z.string()).optional(), // Empty array means all tools are simulated (if simulateToolResponses is true).
     toolSimulationInstructions: z.string().optional(), // A prompt used to guide and generate the simulation result
     maxTurns: z.number().min(1).max(MAX_SIMULATION_TURNS).optional(), // The maximum number of turns to simulate. Default is 1, and any greater value will add a new user message to the simulated conversation.
+    simulatedUserGoal: z.string().optional(), // Deprecated: Use simulatedUserGoalSource instead. Kept for backward compatibility.
+    simulatedUserGoalSource: simulatedUserGoalSourceSchema.optional(), // The source for the simulated user goal (global text or dataset column).
 });
 
 var OptimizationEngine;
@@ -1212,12 +1212,18 @@ var DocumentTriggerParameters;
 })(DocumentTriggerParameters || (DocumentTriggerParameters = {}));
 const DOCUMENT_PATH_REGEXP = /^([\w-]+\/)*([\w-.])+$/;
 
+const translator = new Translator({
+    filterEmptyMessages: true,
+    providerMetadata: 'preserve',
+});
 class ManualInstrumentation {
     enabled;
     tracer;
-    constructor(tracer) {
+    options;
+    constructor(tracer, options) {
         this.enabled = false;
         this.tracer = tracer;
+        this.options = options ?? {};
     }
     isEnabled() {
         return this.enabled;
@@ -1257,36 +1263,6 @@ class ManualInstrumentation {
         }
         return context;
     }
-    capitalize(str) {
-        if (str.length === 0)
-            return str;
-        return str.charAt(0).toUpperCase() + str.toLowerCase().slice(1);
-    }
-    toCamelCase(str) {
-        return str
-            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-            .replace(/[^A-Za-z0-9]+/g, ' ')
-            .trim()
-            .split(' ')
-            .map((w, i) => (i ? this.capitalize(w) : w.toLowerCase()))
-            .join('');
-    }
-    toSnakeCase(str) {
-        return str
-            .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-            .replace(/[^A-Za-z0-9]+/g, '_')
-            .replace(/_+/g, '_')
-            .replace(/^_+|_+$/g, '')
-            .toLowerCase();
-    }
-    toKebabCase(input) {
-        return input
-            .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-            .replace(/[^A-Za-z0-9]+/g, '-')
-            .replace(/-+/g, '-')
-            .replace(/^-+|-+$/g, '')
-            .toLowerCase();
-    }
     error(span, error, options) {
         options = options || {};
         span.recordException(error);
@@ -1334,6 +1310,9 @@ class ManualInstrumentation {
             },
         };
     }
+    unknown(ctx, options) {
+        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Unknown].name, SpanType.Unknown, options);
+    }
     tool(ctx, options) {
         const start = options;
         let jsonArguments = '';
@@ -1353,7 +1332,7 @@ class ManualInstrumentation {
             },
         });
         return {
-            context: span.context,
+            ...span,
             end: (options) => {
                 const end = options;
                 let stringResult = '';
@@ -1376,176 +1355,15 @@ class ManualInstrumentation {
                     },
                 });
             },
-            fail: span.fail,
         };
     }
-    attribifyMessageToolCalls(otelMessageField, toolCalls) {
-        const attributes = {};
-        for (let i = 0; i < toolCalls.length; i++) {
-            for (const key in toolCalls[i]) {
-                const field = this.toCamelCase(key);
-                const value = toolCalls[i][key];
-                if (value === null || value === undefined)
-                    continue;
-                switch (field) {
-                    case 'id':
-                    case 'toolCallId':
-                    case 'toolUseId': {
-                        if (typeof value !== 'string')
-                            continue;
-                        attributes[otelMessageField.toolCalls(i).id] = value;
-                        break;
-                    }
-                    case 'name':
-                    case 'toolName': {
-                        if (typeof value !== 'string')
-                            continue;
-                        attributes[otelMessageField.toolCalls(i).name] = value;
-                        break;
-                    }
-                    case 'arguments':
-                    case 'toolArguments':
-                    case 'input': {
-                        if (typeof value === 'string') {
-                            attributes[otelMessageField.toolCalls(i).arguments] = value;
-                        }
-                        else {
-                            try {
-                                attributes[otelMessageField.toolCalls(i).arguments] =
-                                    JSON.stringify(value);
-                            }
-                            catch (_error) {
-                                attributes[otelMessageField.toolCalls(i).arguments] = '{}';
-                            }
-                        }
-                        break;
-                    }
-                    /* OpenAI function calls */
-                    case 'function': {
-                        if (typeof value !== 'object')
-                            continue;
-                        if (!('name' in value))
-                            continue;
-                        if (typeof value.name !== 'string')
-                            continue;
-                        if (!('arguments' in value))
-                            continue;
-                        if (typeof value.arguments !== 'string')
-                            continue;
-                        attributes[otelMessageField.toolCalls(i).name] = value.name;
-                        attributes[otelMessageField.toolCalls(i).arguments] =
-                            value.arguments;
-                        break;
-                    }
-                }
-            }
-        }
-        return attributes;
-    }
-    attribifyMessageContent(otelMessageField, content) {
-        let attributes = {};
-        if (typeof content === 'string') {
-            return attributes;
-        }
-        try {
-            attributes[otelMessageField.content] = JSON.stringify(content);
-        }
-        catch (_error) {
-            attributes[otelMessageField.content] = '[]';
-        }
-        if (!Array.isArray(content))
-            return attributes;
-        /* Tool calls for Anthropic and PromptL are in the content */
-        const toolCalls = [];
-        for (const item of content) {
-            for (const key in item) {
-                if (this.toCamelCase(key) !== 'type')
-                    continue;
-                if (typeof item[key] !== 'string')
-                    continue;
-                if (item[key] !== 'tool-call' && item[key] !== 'tool_use')
-                    continue;
-                toolCalls.push(item);
-            }
-        }
-        if (toolCalls.length > 0) {
-            attributes = {
-                ...attributes,
-                ...this.attribifyMessageToolCalls(otelMessageField, toolCalls),
-            };
-        }
-        return attributes;
-    }
-    attribifyMessages(direction, messages) {
-        const otelField = direction === 'input'
-            ? ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.prompt
-            : ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.completion;
-        let attributes = {};
-        for (let i = 0; i < messages.length; i++) {
-            for (const key in messages[i]) {
-                const field = this.toCamelCase(key);
-                const value = messages[i][key];
-                if (value === null || value === undefined)
-                    continue;
-                switch (field) {
-                    case 'role': {
-                        if (typeof value !== 'string')
-                            continue;
-                        attributes[otelField.index(i).role] = value;
-                        break;
-                    }
-                    /* Tool calls for Anthropic and PromptL are in the content */
-                    case 'content': {
-                        attributes = {
-                            ...attributes,
-                            ...this.attribifyMessageContent(otelField.index(i), value),
-                        };
-                        break;
-                    }
-                    /* Tool calls for OpenAI */
-                    case 'toolCalls': {
-                        if (!Array.isArray(value))
-                            continue;
-                        attributes = {
-                            ...attributes,
-                            ...this.attribifyMessageToolCalls(otelField.index(i), value),
-                        };
-                        break;
-                    }
-                    /* Tool result for OpenAI / Anthropic / PromptL */
-                    case 'toolCallId':
-                    case 'toolId':
-                    case 'toolUseId': {
-                        if (typeof value !== 'string')
-                            continue;
-                        attributes[otelField.index(i).tool.callId] = value;
-                        break;
-                    }
-                    case 'toolName': {
-                        if (typeof value !== 'string')
-                            continue;
-                        attributes[otelField.index(i).tool.toolName] = value;
-                        break;
-                    }
-                    // Note: 'toolResult' is 'content' itself
-                    case 'isError': {
-                        if (typeof value !== 'boolean')
-                            continue;
-                        attributes[otelField.index(i).tool.isError] = value;
-                        break;
-                    }
-                }
-            }
-        }
-        return attributes;
-    }
     attribifyConfiguration(direction, configuration) {
         const prefix = direction === 'input'
             ? ATTRIBUTES.LATITUDE.request._root
             : ATTRIBUTES.LATITUDE.response._root;
         const attributes = {};
         for (const key in configuration) {
-            const field = this.toSnakeCase(key);
+            const field = toSnakeCase(key);
             let value = configuration[key];
             if (value === null || value === undefined)
                 continue;
@@ -1576,21 +1394,28 @@ class ManualInstrumentation {
         }
         const attrConfiguration = this.attribifyConfiguration('input', configuration);
         const input = start.input ?? [];
+        let jsonSystem = '';
         let jsonInput = '';
         try {
-            jsonInput = JSON.stringify(input);
+            const translated = translator.translate(input, {
+                from: this.options.provider,
+                to: Provider.GenAI,
+                direction: 'input',
+            });
+            jsonSystem = JSON.stringify(translated.system ?? []);
+            jsonInput = JSON.stringify(translated.messages ?? []);
         }
         catch (_error) {
+            jsonSystem = '[]';
             jsonInput = '[]';
         }
-        const attrInput = this.attribifyMessages('input', input);
         const span = this.span(ctx, start.name || `${start.provider} / ${start.model}`, SpanType.Completion, {
             attributes: {
                 [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.system]: start.provider,
                 [ATTRIBUTES.LATITUDE.request.configuration]: jsonConfiguration,
                 ...attrConfiguration,
-                [ATTRIBUTES.LATITUDE.request.messages]: jsonInput,
-                ...attrInput,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.systemInstructions]: jsonSystem,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.input.messages]: jsonInput,
                 ...(start.attributes || {}),
                 [ATTRIBUTES.LATITUDE.commitUuid]: start.versionUuid,
                 [ATTRIBUTES.LATITUDE.documentUuid]: start.promptUuid,
@@ -1598,18 +1423,22 @@ class ManualInstrumentation {
             },
         });
         return {
-            context: span.context,
+            ...span,
             end: (options) => {
                 const end = options ?? {};
                 const output = end.output ?? [];
                 let jsonOutput = '';
                 try {
-                    jsonOutput = JSON.stringify(output);
+                    const translated = translator.translate(output, {
+                        from: this.options.provider,
+                        to: Provider.GenAI,
+                        direction: 'output',
+                    });
+                    jsonOutput = JSON.stringify(translated.messages ?? []);
                 }
                 catch (_error) {
                     jsonOutput = '[]';
                 }
-                const attrOutput = this.attribifyMessages('output', output);
                 const tokens = {
                     prompt: end.tokens?.prompt ?? 0,
                     cached: end.tokens?.cached ?? 0,
@@ -1621,8 +1450,7 @@ class ManualInstrumentation {
                 const finishReason = end.finishReason ?? '';
                 span.end({
                     attributes: {
-                        [ATTRIBUTES.LATITUDE.response.messages]: jsonOutput,
-                        ...attrOutput,
+                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI.output.messages]: jsonOutput,
                         [ATTRIBUTES.OPENTELEMETRY.GEN_AI.usage.inputTokens]: inputTokens,
                         [ATTRIBUTES.OPENTELEMETRY.GEN_AI.usage.outputTokens]: outputTokens,
                         [ATTRIBUTES.LATITUDE.usage.promptTokens]: tokens.prompt,
@@ -1637,7 +1465,6 @@ class ManualInstrumentation {
                     },
                 });
             },
-            fail: span.fail,
         };
     }
     embedding(ctx, options) {
@@ -1649,7 +1476,7 @@ class ManualInstrumentation {
             : ATTRIBUTES.OPENTELEMETRY.HTTP.response.header;
         const attributes = {};
         for (const key in headers) {
-            const field = this.toKebabCase(key);
+            const field = toKebabCase(key);
             const value = headers[key];
             if (value === null || value === undefined)
                 continue;
@@ -1684,7 +1511,7 @@ class ManualInstrumentation {
             },
         });
         return {
-            context: span.context,
+            ...span,
             end: (options) => {
                 const end = options;
                 // Note: do not serialize headers as a single attribute because fields won't be redacted
@@ -1710,7 +1537,6 @@ class ManualInstrumentation {
                     },
                 });
             },
-            fail: span.fail,
         };
     }
     prompt(ctx, { documentLogUuid, versionUuid, promptUuid, projectId, experimentUuid, testDeploymentId, externalId, template, parameters, name, source, ...rest }) {
@@ -1751,7 +1577,9 @@ class ManualInstrumentation {
             ...(source && { [ATTRIBUTES.LATITUDE.source]: source }),
             ...(rest.attributes || {}),
         };
-        return this.span(ctx, name || 'chat', SpanType.Chat, { attributes });
+        return this.span(ctx, name || `chat-${documentLogUuid}`, SpanType.Chat, {
+            attributes,
+        });
     }
     external(ctx, { promptUuid, documentLogUuid, source, versionUuid, externalId, name, ...rest }) {
         const attributes = {
@@ -1791,8 +1619,8 @@ class LatitudeInstrumentation {
         return this.manualTelemetry.isEnabled();
     }
     enable() {
-        this.options.module.instrument(this);
         this.manualTelemetry.enable();
+        this.options.module.instrument(this);
     }
     disable() {
         this.manualTelemetry.disable();
@@ -1987,6 +1815,9 @@ class SpanFactory {
     constructor(telemetry) {
         this.telemetry = telemetry;
     }
+    span(options, ctx) {
+        return this.telemetry.unknown(ctx ?? context.active(), options);
+    }
     tool(options, ctx) {
         return this.telemetry.tool(ctx ?? context.active(), options);
     }
@@ -2020,6 +1851,9 @@ class ContextManager {
     active() {
         return context.active();
     }
+    with(ctx, fn, thisArg, ...args) {
+        return context.with(ctx, fn, thisArg, ...args);
+    }
 }
 class InstrumentationManager {
     instrumentations;
@@ -2066,6 +1900,23 @@ class ScopedTracerProvider {
         return this.provider.getTracer(this.scope, this.version, options);
     }
 }
+class LifecycleManager {
+    nodeProvider;
+    exporter;
+    constructor(nodeProvider, exporter) {
+        this.nodeProvider = nodeProvider;
+        this.exporter = exporter;
+    }
+    async flush() {
+        await this.nodeProvider.forceFlush();
+        await this.exporter.forceFlush?.();
+    }
+    async shutdown() {
+        await this.flush();
+        await this.nodeProvider.shutdown();
+        await this.exporter.shutdown?.();
+    }
+}
 const DEFAULT_SPAN_EXPORTER = (apiKey) => new OTLPTraceExporter({
     url: TRACES_URL,
     headers: {
@@ -2084,6 +1935,7 @@ var Instrumentation;
     Instrumentation["Langchain"] = "langchain";
     Instrumentation["Latitude"] = "latitude";
     Instrumentation["LlamaIndex"] = "llamaindex";
+    Instrumentation["Manual"] = "manual";
     Instrumentation["OpenAI"] = "openai";
     Instrumentation["TogetherAI"] = "togetherai";
     Instrumentation["VertexAI"] = "vertexai";
@@ -2097,6 +1949,7 @@ class LatitudeTelemetry {
     context;
     instrumentation;
     tracer;
+    lifecycle;
     constructor(apiKey, options) {
         this.options = options || {};
         if (!this.options.exporter) {
@@ -2113,6 +1966,7 @@ class LatitudeTelemetry {
         this.nodeProvider = new NodeTracerProvider({
             resource: new Resource({ [ATTR_SERVICE_NAME]: SERVICE_NAME }),
         });
+        this.lifecycle = new LifecycleManager(this.nodeProvider, this.options.exporter);
         // Note: important, must run before the exporter span processors
         this.nodeProvider.addSpanProcessor(new BaggageSpanProcessor(ALLOW_ALL_BAGGAGE_KEYS));
         if (this.options.processors) {
@@ -2142,19 +1996,16 @@ class LatitudeTelemetry {
         this.context = new ContextManager(this.manualInstrumentation);
     }
     async flush() {
-        await this.nodeProvider.forceFlush();
-        await this.options.exporter.forceFlush?.();
+        await this.lifecycle.flush();
     }
     async shutdown() {
-        await this.flush();
-        await this.nodeProvider.shutdown();
-        await this.options.exporter.shutdown?.();
+        await this.lifecycle.shutdown();
     }
     // TODO(tracing): auto instrument outgoing HTTP requests
     initInstrumentations() {
         this.instrumentationsList = [];
-        const tracer = this.tracer.get(InstrumentationScope.Manual);
-        this.manualInstrumentation = new ManualInstrumentation(tracer);
+        const tracer = this.tracer.get(Instrumentation.Manual);
+        this.manualInstrumentation = new ManualInstrumentation(tracer, this.options.instrumentations?.manual);
         this.instrumentationsList.push(this.manualInstrumentation);
         const latitude = this.options.instrumentations?.latitude;
         if (latitude) {
@@ -2164,12 +2015,12 @@ class LatitudeTelemetry {
         }
         const configureInstrumentation = (instrumentationType, InstrumentationConstructor, instrumentationOptions) => {
             const providerPkg = this.options.instrumentations?.[instrumentationType];
+            if (!providerPkg)
+                return;
             const provider = this.tracer.provider(instrumentationType);
             const instrumentation = new InstrumentationConstructor(instrumentationOptions); // prettier-ignore
             instrumentation.setTracerProvider(provider);
-            if (providerPkg) {
-                instrumentation.manuallyInstrument(providerPkg);
-            }
+            instrumentation.manuallyInstrument(providerPkg);
             registerInstrumentations({
                 instrumentations: [instrumentation],
                 tracerProvider: provider,
@@ -2191,19 +2042,17 @@ class LatitudeTelemetry {
         if (!DOCUMENT_PATH_REGEXP.test(options.path)) {
             throw new BadRequestError("Invalid path, no spaces. Only letters, numbers, '.', '-' and '_'");
         }
-        const span = this.manualInstrumentation.unresolvedExternal(otel.ROOT_CONTEXT, options);
+        const span = this.manualInstrumentation.unresolvedExternal(BACKGROUND(), options);
+        let result;
         try {
-            const result = await context.with(span.context, () => fn(span.context));
-            span.end();
-            return result;
+            result = await context.with(span.context, async () => await fn(span.context));
         }
         catch (error) {
             span.fail(error);
             throw error;
         }
-        finally {
-            await this.flush();
-        }
+        span.end();
+        return result;
     }
 }