Skip to content

Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.

feat: Add server attributes in langchain instrumentation (#1182)

Ishan Jain87520afb5b1e
diff --git a/sdk/python/src/openlit/__init__.py b/sdk/python/src/openlit/__init__.py
index 78d41b7e..fd733774 100644
--- a/sdk/python/src/openlit/__init__.py
+++ b/sdk/python/src/openlit/__init__.py
@@ -145,10 +145,12 @@ def apply_controller_mode_defaults(controller_mode, disabled_instrumentors):
if controller_mode != "agent_observability":
return normalized_disabled
- merged = list(dict.fromkeys(
- normalized_disabled
- + normalize_instrumentor_names(CONTROLLER_MANAGED_DISABLED_INSTRUMENTORS)
- ))
+ merged = list(
+ dict.fromkeys(
+ normalized_disabled
+ + normalize_instrumentor_names(CONTROLLER_MANAGED_DISABLED_INSTRUMENTORS)
+ )
+ )
logger.info(
"Controller-managed agent observability mode enabled; default duplicate-prone instrumentors will be disabled"
)
diff --git a/sdk/python/src/openlit/instrumentation/langchain/__init__.py b/sdk/python/src/openlit/instrumentation/langchain/__init__.py
index b6bb8413..63740879 100644
--- a/sdk/python/src/openlit/instrumentation/langchain/__init__.py
+++ b/sdk/python/src/openlit/instrumentation/langchain/__init__.py
@@ -449,6 +449,40 @@ def _resolve_conversation_id(metadata: Optional[Dict[str, Any]]) -> Optional[str
return None
+_API_BASE_KEYS = (
+ "api_base",
+ "base_url",
+ "openai_api_base",
+ "openai_proxy",
+ "azure_endpoint",
+ "endpoint",
+ "host",
+)
+
+
+def _resolve_api_base(
+ serialized: Optional[Dict[str, Any]], kwargs: Dict[str, Any]
+) -> Optional[str]:
+ """Find an explicit API base URL from langchain callback inputs.
+
+ LangChain passes connection details inconsistently across providers and
+ versions: some put it in `invocation_params`, others only inside
+ `serialized["kwargs"]`. Check both, then a few common keys.
+ """
+ invocation_params = kwargs.get("invocation_params") or {}
+ for key in _API_BASE_KEYS:
+ val = invocation_params.get(key)
+ if val:
+ return str(val)
+
+ serialized_kwargs = (serialized or {}).get("kwargs") or {}
+ for key in _API_BASE_KEYS:
+ val = serialized_kwargs.get(key)
+ if val:
+ return str(val)
+ return None
+
+
# =============================================================================
# Callback Handler
# =============================================================================
@@ -485,7 +519,6 @@ def _create_callback_handler_class(
is_langgraph_wrapper_active,
set_framework_llm_active,
reset_framework_llm_active,
- get_server_address_for_provider,
)
from openlit.semcov import SemanticConvention
@@ -605,6 +638,47 @@ def _create_callback_handler_class(
)
span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION, self._version)
+ def _resolve_and_set_server(
+ self, run_id, span, provider, serialized, kwargs
+ ) -> None:
+ """Resolve server.address/port and set them on the span and holder.
+
+ Setting these on the span at start (rather than only at on_llm_end)
+ guarantees they are present on error spans too — see issue #1169.
+ """
+ from openlit.__helpers import get_server_address_for_provider
+
+ holder = self.spans[run_id]
+
+ api_base = _resolve_api_base(serialized, kwargs)
+ if api_base:
+ try:
+ from urllib.parse import urlparse
+
+ parsed = urlparse(api_base)
+ if parsed.hostname:
+ holder.server_address = parsed.hostname
+ if parsed.port:
+ holder.server_port = parsed.port
+ elif parsed.scheme == "http":
+ holder.server_port = 80
+ else:
+ holder.server_port = 443
+ except Exception:
+ pass
+
+ if not holder.server_address:
+ default_host, default_port = get_server_address_for_provider(provider)
+ if default_host:
+ holder.server_address = default_host
+ holder.server_port = default_port
+
+ if holder.server_address:
+ span.set_attribute(
+ SemanticConvention.SERVER_ADDRESS, holder.server_address
+ )
+ span.set_attribute(SemanticConvention.SERVER_PORT, holder.server_port)
+
def _extract_from_generations(
self,
holder,
@@ -1046,27 +1120,7 @@ def _create_callback_handler_class(
self.spans[run_id].prompts = prompts if prompts else []
self.spans[run_id].provider = provider
- # Resolve server address from invocation_params or provider defaults
- invocation_params = kwargs.get("invocation_params", {})
- api_base = invocation_params.get("api_base") or invocation_params.get(
- "base_url"
- )
- if api_base:
- try:
- from urllib.parse import urlparse
-
- parsed = urlparse(api_base)
- self.spans[run_id].server_address = parsed.hostname or ""
- self.spans[run_id].server_port = parsed.port or 443
- except Exception:
- pass
- if not self.spans[run_id].server_address:
- default_host, default_port = get_server_address_for_provider(
- provider
- )
- if default_host:
- self.spans[run_id].server_address = default_host
- self.spans[run_id].server_port = default_port
+ self._resolve_and_set_server(run_id, span, provider, serialized, kwargs)
if prompts:
prompt_str = truncate_content("\n".join(prompts))
@@ -1133,27 +1187,7 @@ def _create_callback_handler_class(
self.spans[run_id].model_parameters = model_params
self.spans[run_id].provider = provider
- # Resolve server address from invocation_params or provider defaults
- invocation_params = kwargs.get("invocation_params", {})
- api_base = invocation_params.get("api_base") or invocation_params.get(
- "base_url"
- )
- if api_base:
- try:
- from urllib.parse import urlparse
-
- parsed = urlparse(api_base)
- self.spans[run_id].server_address = parsed.hostname or ""
- self.spans[run_id].server_port = parsed.port or 443
- except Exception:
- pass
- if not self.spans[run_id].server_address:
- default_host, default_port = get_server_address_for_provider(
- provider
- )
- if default_host:
- self.spans[run_id].server_address = default_host
- self.spans[run_id].server_port = default_port
+ self._resolve_and_set_server(run_id, span, provider, serialized, kwargs)
# Always calculate prompt content for token estimation
if messages:
@@ -2476,9 +2510,9 @@ class LangChainInstrumentor(BaseInstrumentor):
try:
wrap_function_wrapper(
- module="langchain_core.callbacks.manager",
- name="BaseCallbackManager.__init__",
- wrapper=_BaseCallbackManagerInitWrapper(handler_instance),
+ "langchain_core.callbacks.manager",
+ "BaseCallbackManager.__init__",
+ _BaseCallbackManagerInitWrapper(handler_instance),
)
logger.debug("Successfully wrapped BaseCallbackManager.__init__")
except Exception as e:
@@ -2486,11 +2520,9 @@ class LangChainInstrumentor(BaseInstrumentor):
try:
wrap_function_wrapper(
- module="langchain.agents",
- name="create_agent",
- wrapper=_wrap_create_agent(
- tracer, version, environment, application_name
- ),
+ "langchain.agents",
+ "create_agent",
+ _wrap_create_agent(tracer, version, environment, application_name),
)
logger.debug("Successfully wrapped langchain.agents.create_agent")
except Exception:
@@ -2509,9 +2541,9 @@ class LangChainInstrumentor(BaseInstrumentor):
for method_name in ("embed_documents", "embed_query"):
try:
wrap_function_wrapper(
- module="langchain_core.embeddings",
- name=f"Embeddings.{method_name}",
- wrapper=_wrap_embed(**embed_kwargs),
+ "langchain_core.embeddings",
+ f"Embeddings.{method_name}",
+ _wrap_embed(**embed_kwargs),
)
logger.debug("Successfully wrapped Embeddings.%s", method_name)
except Exception:
@@ -2520,9 +2552,9 @@ class LangChainInstrumentor(BaseInstrumentor):
for method_name in ("aembed_documents", "aembed_query"):
try:
wrap_function_wrapper(
- module="langchain_core.embeddings",
- name=f"Embeddings.{method_name}",
- wrapper=_wrap_embed_async(**embed_kwargs),
+ "langchain_core.embeddings",
+ f"Embeddings.{method_name}",
+ _wrap_embed_async(**embed_kwargs),
)
logger.debug("Successfully wrapped Embeddings.%s", method_name)
except Exception:
diff --git a/sdk/typescript/src/helpers.ts b/sdk/typescript/src/helpers.ts
index 2f0f0ee5..6b412927 100644
--- a/sdk/typescript/src/helpers.ts
+++ b/sdk/typescript/src/helpers.ts
@@ -151,6 +151,7 @@ const PROVIDER_DEFAULT_ENDPOINTS: Record<string, [string, number]> = {
deepseek: ['api.deepseek.com', 443],
x_ai: ['api.x.ai', 443],
huggingface: ['api-inference.huggingface.co', 443],
+ cursor: ['api2.cursor.sh', 443],
};
export function getServerAddressForProvider(provider: string): [string, number] {
diff --git a/sdk/typescript/src/instrumentation/cursor-sdk/index.ts b/sdk/typescript/src/instrumentation/cursor-sdk/index.ts
new file mode 100644
index 00000000..5f446c4e
--- /dev/null
+++ b/sdk/typescript/src/instrumentation/cursor-sdk/index.ts
@@ -0,0 +1,74 @@
+/**
+ * OpenLIT Cursor SDK Instrumentation
+ *
+ * Provides auto-instrumentation for @cursor/sdk including:
+ * - Agent.create() wrapping (create_agent spans + send() patching)
+ * - Agent.resume() wrapping (send() patching on resumed agents)
+ * - agent.send() wrapping (invoke_agent spans with streaming tool child spans)
+ *
+ * Agent.prompt() is covered automatically since it calls create() + send().
+ *
+ * OTel GenAI semantic convention compliant.
+ */
+
+import {
+ InstrumentationBase,
+ InstrumentationModuleDefinition,
+ InstrumentationNodeModuleDefinition,
+} from '@opentelemetry/instrumentation';
+import type { InstrumentationConfig } from '@opentelemetry/instrumentation';
+
+import { INSTRUMENTATION_PREFIX } from '../../constant';
+import { patchAgentCreate, patchAgentResume } from './wrapper';
+
+const SUPPORTED_VERSIONS = ['>=0.1.0'];
+
+export default class CursorSDKInstrumentation extends InstrumentationBase {
+ constructor(config: InstrumentationConfig = {}) {
+ super(`${INSTRUMENTATION_PREFIX}/instrumentation-cursor-sdk`, '1.0.0', config);
+ }
+
+ protected init(): InstrumentationModuleDefinition | InstrumentationModuleDefinition[] | void {
+ const module = new InstrumentationNodeModuleDefinition(
+ '@cursor/sdk',
+ SUPPORTED_VERSIONS,
+ (moduleExports: any) => {
+ return this._patch(moduleExports);
+ },
+ (moduleExports: any) => {
+ this._unpatch(moduleExports);
+ return moduleExports;
+ },
+ );
+ return module;
+ }
+
+ public manualPatch(moduleExports: any): any {
+ return this._patch(moduleExports);
+ }
+
+ private _patch(moduleExports: any): any {
+ try {
+ const tracer = this.tracer;
+ const AgentClass = moduleExports.Agent;
+
+ if (!AgentClass) return moduleExports;
+
+ if (typeof AgentClass.create === 'function') {
+ const originalCreate = AgentClass.create;
+ AgentClass.create = patchAgentCreate(tracer)(originalCreate);
+ }
+
+ if (typeof AgentClass.resume === 'function') {
+ const originalResume = AgentClass.resume;
+ AgentClass.resume = patchAgentResume(tracer)(originalResume);
+ }
+
+ } catch { /* graceful degradation */ }
+ return moduleExports;
+ }
+
+ private _unpatch(_moduleExports: any): void {
+ // InstrumentationBase handles restoring originals on disable
+ }
+}
diff --git a/sdk/typescript/src/instrumentation/cursor-sdk/wrapper.ts b/sdk/typescript/src/instrumentation/cursor-sdk/wrapper.ts
new file mode 100644
index 00000000..404e13d8
--- /dev/null
+++ b/sdk/typescript/src/instrumentation/cursor-sdk/wrapper.ts
@@ -0,0 +1,788 @@
+/**
+ * Cursor SDK wrapper -- OTel GenAI semantic convention compliant.
+ *
+ * Wraps Agent.create(), Agent.resume(), and agent.send()
+ * to produce `create_agent`, `invoke_agent`, and `execute_tool` spans.
+ *
+ * Agent.prompt() is NOT wrapped separately -- it internally calls
+ * create() + send(), so the patched versions handle it automatically
+ * without producing duplicate spans.
+ *
+ * Token usage is captured via onDelta injection (TurnEndedUpdate).
+ * Tool call spans are created from SDKMessage stream events.
+ * The `system` stream event provides resolved model and tool definitions.
+ */
+
+import {
+ Tracer,
+ Span,
+ SpanKind,
+ SpanStatusCode,
+ SpanContext,
+ context as otelContext,
+ trace,
+ Link,
+} from '@opentelemetry/api';
+import { ATTR_SERVICE_NAME, ATTR_TELEMETRY_SDK_NAME } from '@opentelemetry/semantic-conventions';
+import SemanticConvention from '../../semantic-convention';
+import OpenlitConfig from '../../config';
+import OpenLitHelper, {
+ applyCustomSpanAttributes,
+ getServerAddressForProvider,
+ setFrameworkLlmActive,
+ resetFrameworkLlmActive,
+} from '../../helpers';
+import { SDK_NAME, SDK_VERSION } from '../../constant';
+import Metrics from '../../otel/metrics';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const [SERVER_ADDRESS, SERVER_PORT] = getServerAddressForProvider('cursor');
+
+const CURSOR_STATUS_TO_FINISH_REASON: Record<string, string> = {
+ finished: 'stop',
+ error: 'error',
+ cancelled: 'cancelled',
+};
+
+// ---------------------------------------------------------------------------
+// Agent creation registry -- links invoke_agent back to create_agent
+// ---------------------------------------------------------------------------
+
+class AgentCreationRegistry {
+ private _contexts = new WeakMap<object, SpanContext>();
+
+ register(agent: object, spanContext: SpanContext): void {
+ this._contexts.set(agent, spanContext);
+ }
+
+ get(agent: object): SpanContext | undefined {
+ return this._contexts.get(agent);
+ }
+}
+
+const agentRegistry = new AgentCreationRegistry();
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function truncateContent(content: string): string {
+ const maxLen = OpenlitConfig.maxContentLength;
+ if (maxLen != null && maxLen > 0 && content.length > maxLen) {
+ return content.slice(0, maxLen);
+ }
+ return content;
+}
+
+function mapRunStatusToFinishReason(status: string | undefined): string {
+ if (!status) return 'stop';
+ return CURSOR_STATUS_TO_FINISH_REASON[status] || status;
+}
+
+function resolveAgentName(options: any): string | null {
+ if (!options) return null;
+ const name = options.name;
+ if (name && typeof name === 'string' && name.trim()) return name.trim();
+ return null;
+}
+
+function resolveModelId(options: any): string | null {
+ if (!options?.model) return null;
+ const model = options.model;
+ if (typeof model === 'string') return model;
+ if (typeof model === 'object' && model.id) return String(model.id);
+ return null;
+}
+
+function setCommonSpanAttributes(span: Span): void {
+ span.setAttribute(ATTR_TELEMETRY_SDK_NAME, SDK_NAME);
+ span.setAttribute(SemanticConvention.ATTR_DEPLOYMENT_ENVIRONMENT, OpenlitConfig.environment ?? 'default');
+ span.setAttribute(ATTR_SERVICE_NAME, OpenlitConfig.applicationName ?? 'default');
+ span.setAttribute(SemanticConvention.GEN_AI_SDK_VERSION, SDK_VERSION);
+ span.setAttribute(SemanticConvention.SERVER_ADDRESS, SERVER_ADDRESS);
+ span.setAttribute(SemanticConvention.SERVER_PORT, SERVER_PORT);
+}
+
+// ---------------------------------------------------------------------------
+// Tool span tracker -- manages in-flight execute_tool spans from stream
+// ---------------------------------------------------------------------------
+
+class ToolSpanTracker {
+ private _tracer: Tracer;
+ private _parentSpan: Span;
+ private _captureContent: boolean;
+ private _inFlight = new Map<string, Span>();
+
+ constructor(tracer: Tracer, parentSpan: Span, captureContent: boolean) {
+ this._tracer = tracer;
+ this._parentSpan = parentSpan;
+ this._captureContent = captureContent;
+ }
+
+ startTool(toolName: string, callId: string, args?: unknown): void {
+ const spanName = `${SemanticConvention.GEN_AI_OPERATION_TYPE_TOOLS} ${toolName}`;
+ const parentCtx = trace.setSpan(otelContext.active(), this._parentSpan);
+
+ const span = this._tracer.startSpan(spanName, {
+ kind: SpanKind.INTERNAL,
+ attributes: {
+ [SemanticConvention.GEN_AI_OPERATION]: SemanticConvention.GEN_AI_OPERATION_TYPE_TOOLS,
+ [SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL]: SemanticConvention.GEN_AI_SYSTEM_CURSOR,
+ },
+ }, parentCtx);
+
+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_NAME, toolName);
+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_CALL_ID, callId);
+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE_OTEL, 'extension');
+
+ setCommonSpanAttributes(span);
+
+ if (this._captureContent && args != null) {
+ try {
+ const argsStr = typeof args === 'string' ? args : JSON.stringify(args);
+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_CALL_ARGUMENTS, truncateContent(argsStr));
+ } catch { /* ignore */ }
+ }
+
+ applyCustomSpanAttributes(span);
+ this._inFlight.set(callId, span);
+ }
+
+ endTool(callId: string, result?: unknown, isError = false): void {
+ const span = this._inFlight.get(callId);
+ if (!span) return;
+ this._inFlight.delete(callId);
+
+ if (isError) {
+ span.setAttribute(SemanticConvention.ERROR_TYPE, 'ToolExecutionError');
+ span.setStatus({ code: SpanStatusCode.ERROR, message: 'tool execution failed' });
+ } else {
+ if (this._captureContent && result != null) {
+ try {
+ const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_CALL_RESULT, truncateContent(resultStr));
+ } catch { /* ignore */ }
+ }
+ span.setStatus({ code: SpanStatusCode.OK });
+ }
+
+ span.end();
+ }
+
+ endAll(): void {
+ for (const [, span] of this._inFlight) {
+ span.setStatus({ code: SpanStatusCode.OK });
+ span.end();
+ }
+ this._inFlight.clear();
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Process SDKMessage stream events for tool spans and content capture
+// ---------------------------------------------------------------------------
+
+interface StreamState {
+ assistantText: string;
+ thinkingText: string;
+ toolCalls: Array<{ name: string; callId: string; args?: unknown; result?: unknown }>;
+ resolvedModel: string | null;
+ toolDefinitions: string[] | null;
+ runId: string | null;
+ firstContentTimeMs: number | null;
+}
+
+function processStreamEvent(
+ event: any,
+ toolTracker: ToolSpanTracker,
+ state: StreamState,
+): void {
+ if (!event || !event.type) return;
+
+ if (!state.runId && event.run_id) {
+ state.runId = event.run_id;
+ }
+
+ switch (event.type) {
+ case 'system': {
+ if (event.model) {
+ const modelId = typeof event.model === 'string' ? event.model : event.model?.id;
+ if (modelId) state.resolvedModel = String(modelId);
+ }
+ if (Array.isArray(event.tools) && event.tools.length > 0) {
+ state.toolDefinitions = event.tools.map(String);
+ }
+ break;
+ }
+ case 'tool_call': {
+ const callId = event.call_id;
+ const toolName = event.name || 'unknown';
+ const status = event.status;
+
+ if (status === 'running') {
+ toolTracker.startTool(toolName, callId, event.args);
+ state.toolCalls.push({ name: toolName, callId, args: event.args });
+ } else if (status === 'completed') {
+ toolTracker.endTool(callId, event.result, false);
+ const tc = state.toolCalls.find(t => t.callId === callId);
+ if (tc) tc.result = event.result;
+ } else if (status === 'error') {
+ toolTracker.endTool(callId, event.result, true);
+ }
+ break;
+ }
+ case 'assistant': {
+ if (state.firstContentTimeMs === null) {
+ state.firstContentTimeMs = Date.now();
+ }
+ const content = event.message?.content;
+ if (Array.isArray(content)) {
+ for (const block of content) {
+ if (block.type === 'text' && block.text) {
+ state.assistantText += block.text;
+ }
+ }
+ }
+ break;
+ }
+ case 'thinking': {
+ if (state.firstContentTimeMs === null) {
+ state.firstContentTimeMs = Date.now();
+ }
+ if (event.text) {
+ state.thinkingText += event.text;
+ }
+ break;
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Build OTel input/output messages
+// ---------------------------------------------------------------------------
+
+function buildInputMessages(message: string | any): string | null {
+ try {
+ if (typeof message === 'string') {
+ return JSON.stringify([{
+ role: 'user',
+ parts: [{ type: 'text', content: truncateContent(message) }],
+ }]);
+ }
+
+ const parts: any[] = [];
+ if (message?.text) {
+ parts.push({ type: 'text', content: truncateContent(message.text) });
+ }
+ if (Array.isArray(message?.images)) {
+ for (const img of message.images) {
+ parts.push({ type: 'image', mimeType: img.mimeType || 'image/png' });
+ }
+ }
+ if (parts.length === 0) return null;
+ return JSON.stringify([{ role: 'user', parts }]);
+ } catch { return null; }
+}
+
+function buildOutputMessages(state: StreamState, finishReason: string): string | null {
+ try {
+ const parts: any[] = [];
+
+ if (state.assistantText) {
+ parts.push({ type: 'text', content: truncateContent(state.assistantText) });
+ }
+
+ if (state.thinkingText) {
+ parts.push({ type: 'reasoning', content: truncateContent(state.thinkingText) });
+ }
+
+ for (const tc of state.toolCalls) {
+ const toolPart: any = {
+ type: 'tool_call',
+ id: tc.callId,
+ name: tc.name,
+ };
+ if (tc.args != null) {
+ toolPart.arguments = typeof tc.args === 'object' ? tc.args : {};
+ }
+ parts.push(toolPart);
+ }
+
+ if (parts.length === 0) return null;
+ return JSON.stringify([{ role: 'assistant', parts, finish_reason: finishReason }]);
+ } catch { return null; }
+}
+
+// ---------------------------------------------------------------------------
+// Emit inference event for invoke_agent spans
+// ---------------------------------------------------------------------------
+
+function emitInvokeAgentEvent(
+ span: Span,
+ agentId: string | null,
+ model: string | null,
+ responseModel: string | null,
+ finishReason: string,
+ inputTokens: number,
+ outputTokens: number,
+ inputMessagesJson: string | null,
+ outputMessagesJson: string | null,
+): void {
+ if (OpenlitConfig.disableEvents) return;
+
+ try {
+ const attributes: Record<string, any> = {
+ [SemanticConvention.GEN_AI_OPERATION]: SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+ [SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL]: SemanticConvention.GEN_AI_SYSTEM_CURSOR,
+ [SemanticConvention.SERVER_ADDRESS]: SERVER_ADDRESS,
+ [SemanticConvention.SERVER_PORT]: SERVER_PORT,
+ };
+
+ if (model) attributes[SemanticConvention.GEN_AI_REQUEST_MODEL] = model;
+ if (responseModel) attributes[SemanticConvention.GEN_AI_RESPONSE_MODEL] = responseModel;
+ if (agentId) attributes[SemanticConvention.GEN_AI_CONVERSATION_ID] = agentId;
+ if (finishReason) attributes[SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON] = [finishReason];
+ if (inputTokens) attributes[SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS] = inputTokens;
+ if (outputTokens) attributes[SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS] = outputTokens;
+
+ if (inputMessagesJson != null) {
+ attributes[SemanticConvention.GEN_AI_INPUT_MESSAGES] = inputMessagesJson;
+ }
+ if (outputMessagesJson != null) {
+ attributes[SemanticConvention.GEN_AI_OUTPUT_MESSAGES] = outputMessagesJson;
+ }
+
+ OpenLitHelper.emitInferenceEvent(span, attributes);
+ } catch { /* swallow */ }
+}
+
+// ---------------------------------------------------------------------------
+// Record metrics for invoke_agent spans
+// ---------------------------------------------------------------------------
+
+function recordInvokeAgentMetrics(
+ model: string | null,
+ inputTokens: number,
+ outputTokens: number,
+ cost: number,
+ duration: number,
+ errorType?: string,
+): void {
+ if (OpenlitConfig.disableMetrics) return;
+
+ try {
+ const attributes: Record<string, any> = {
+ [ATTR_TELEMETRY_SDK_NAME]: SDK_NAME,
+ [ATTR_SERVICE_NAME]: OpenlitConfig.applicationName ?? 'default',
+ [SemanticConvention.ATTR_DEPLOYMENT_ENVIRONMENT]: OpenlitConfig.environment ?? 'default',
+ [SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL]: SemanticConvention.GEN_AI_SYSTEM_CURSOR,
+ [SemanticConvention.GEN_AI_OPERATION]: SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+ [SemanticConvention.SERVER_ADDRESS]: SERVER_ADDRESS,
+ [SemanticConvention.SERVER_PORT]: SERVER_PORT,
+ };
+ if (model) attributes[SemanticConvention.GEN_AI_REQUEST_MODEL] = model;
+ if (errorType) attributes[SemanticConvention.ERROR_TYPE] = errorType;
+
+ if (Metrics.genaiClientOperationDuration) {
+ Metrics.genaiClientOperationDuration.record(duration, attributes);
+ }
+
+ if (inputTokens && Metrics.genaiClientUsageTokens) {
+ Metrics.genaiClientUsageTokens.record(inputTokens, {
+ ...attributes,
+ [SemanticConvention.GEN_AI_TOKEN_TYPE]: SemanticConvention.GEN_AI_TOKEN_TYPE_INPUT,
+ });
+ }
+ if (outputTokens && Metrics.genaiClientUsageTokens) {
+ Metrics.genaiClientUsageTokens.record(outputTokens, {
+ ...attributes,
+ [SemanticConvention.GEN_AI_TOKEN_TYPE]: SemanticConvention.GEN_AI_TOKEN_TYPE_OUTPUT,
+ });
+ }
+ if (cost && Metrics.genaiCost) {
+ Metrics.genaiCost.record(cost, attributes);
+ }
+ } catch { /* swallow */ }
+}
+
+// ---------------------------------------------------------------------------
+// wrapSend -- wraps agent.send() to produce invoke_agent spans
+// ---------------------------------------------------------------------------
+
+function wrapSend(
+ tracer: Tracer,
+ originalSend: any,
+ agentId: string,
+ agentName: string | null,
+ modelId: string | null,
+): any {
+ return function wrappedSend(this: any, message: any, options?: any) {
+ const captureContent = OpenlitConfig.captureMessageContent ?? true;
+ const displayName = agentName || agentId;
+ const spanName = `${SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT} ${displayName}`;
+ const requestModel = modelId || resolveModelId(options) || 'unknown';
+
+ const creationSpanCtx = agentRegistry.get(this);
+ const links: Link[] = [];
+ if (creationSpanCtx) {
+ links.push({ context: creationSpanCtx });
+ }
+
+ // Start invoke_agent in the same trace as create_agent by using its
+ // span context as parent. This keeps both spans in one trace while
+ // the span link provides explicit correlation.
+ let parentCtx = otelContext.active();
+ if (creationSpanCtx) {
+ const remoteSpan = trace.wrapSpanContext(creationSpanCtx);
+ parentCtx = trace.setSpan(parentCtx, remoteSpan);
+ }
+
+ const span = tracer.startSpan(spanName, {
+ kind: SpanKind.CLIENT,
+ attributes: {
+ [SemanticConvention.GEN_AI_OPERATION]: SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+ [SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL]: SemanticConvention.GEN_AI_SYSTEM_CURSOR,
+ [SemanticConvention.GEN_AI_REQUEST_MODEL]: requestModel,
+ [SemanticConvention.SERVER_ADDRESS]: SERVER_ADDRESS,
+ [SemanticConvention.SERVER_PORT]: SERVER_PORT,
+ },
+ links,
+ }, parentCtx);
+
+ setCommonSpanAttributes(span);
+ span.setAttribute(SemanticConvention.GEN_AI_AGENT_ID, agentId);
+ span.setAttribute(SemanticConvention.GEN_AI_CONVERSATION_ID, agentId);
+ if (agentName) span.setAttribute(SemanticConvention.GEN_AI_AGENT_NAME, agentName);
+
+ if (captureContent) {
+ const inputJson = buildInputMessages(message);
+ if (inputJson) span.setAttribute(SemanticConvention.GEN_AI_INPUT_MESSAGES, inputJson);
+ }
+
+ applyCustomSpanAttributes(span);
+
+ const startTime = Date.now() / 1000;
+ const startTimeMs = Date.now();
+ const usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
+ const toolTracker = new ToolSpanTracker(tracer, span, captureContent);
+ const streamState: StreamState = {
+ assistantText: '',
+ thinkingText: '',
+ toolCalls: [],
+ resolvedModel: null,
+ toolDefinitions: null,
+ runId: null,
+ firstContentTimeMs: null,
+ };
+
+ const userOnDelta = options?.onDelta;
+ const mergedOptions = { ...options };
+ mergedOptions.onDelta = async (args: any) => {
+ try {
+ const update = args?.update;
+ if (update?.type === 'turn-ended' && update.usage) {
+ usage.inputTokens += update.usage.inputTokens || 0;
+ usage.outputTokens += update.usage.outputTokens || 0;
+ usage.cacheReadTokens += update.usage.cacheReadTokens || 0;
+ usage.cacheWriteTokens += update.usage.cacheWriteTokens || 0;
+ }
+ } catch { /* swallow */ }
+
+ if (userOnDelta) {
+ return userOnDelta(args);
+ }
+ };
+
+ const spanContext = trace.setSpan(otelContext.active(), span);
+
+ setFrameworkLlmActive();
+ let runPromise: Promise<any>;
+ try {
+ runPromise = otelContext.with(spanContext, () => {
+ return originalSend.call(this, message, mergedOptions);
+ });
+ } catch (e: any) {
+ resetFrameworkLlmActive();
+ OpenLitHelper.handleException(span, e);
+ span.end();
+ throw e;
+ }
+
+ return runPromise.then((run: any) => {
+ return createRunProxy(
+ run, tracer, span, startTime, startTimeMs, usage, toolTracker,
+ streamState, captureContent, agentId, agentName, requestModel, message,
+ );
+ }).catch((e: any) => {
+ resetFrameworkLlmActive();
+ OpenLitHelper.handleException(span, e);
+ recordInvokeAgentMetrics(
+ requestModel, 0, 0, 0,
+ (Date.now() / 1000) - startTime,
+ e?.constructor?.name || '_OTHER',
+ );
+ span.end();
+ throw e;
+ });
+ };
+}
+
+// ---------------------------------------------------------------------------
+// createRunProxy -- proxies the Run to intercept stream() and wait()
+// ---------------------------------------------------------------------------
+
+function createRunProxy(
+ run: any,
+ tracer: Tracer,
+ span: Span,
+ startTime: number,
+ startTimeMs: number,
+ usage: { inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number },
+ toolTracker: ToolSpanTracker,
+ streamState: StreamState,
+ captureContent: boolean,
+ agentId: string,
+ agentName: string | null,
+ requestModel: string,
+ message: any,
+): any {
+ let finalized = false;
+ let isStreamMode = false;
+
+ const finalizeSpan = (result?: any, error?: any) => {
+ if (finalized) return;
+ finalized = true;
+
+ resetFrameworkLlmActive();
+ toolTracker.endAll();
+
+ const duration = (Date.now() / 1000) - startTime;
+ const status = result?.status || run.status || 'finished';
+ const finishReason = mapRunStatusToFinishReason(status);
+ const responseModel = streamState.resolvedModel || result?.model?.id || run.model?.id || null;
+ const durationMs = result?.durationMs || run.durationMs;
+
+ if (responseModel) span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, responseModel);
+ span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [finishReason]);
+
+ const runId = streamState.runId || run.id;
+ if (runId) span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_ID, runId);
+
+ if (isStreamMode) {
+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_STREAM, true);
+ }
+
+ if (usage.inputTokens) span.setAttribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, usage.inputTokens);
+ if (usage.outputTokens) span.setAttribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, usage.outputTokens);
+ if (usage.cacheReadTokens) span.setAttribute(SemanticConvention.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, usage.cacheReadTokens);
+ if (usage.cacheWriteTokens) span.setAttribute(SemanticConvention.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS, usage.cacheWriteTokens);
+
+ const effectiveDuration = durationMs ? durationMs / 1000 : duration;
+ span.setAttribute(SemanticConvention.GEN_AI_CLIENT_OPERATION_DURATION, effectiveDuration);
+
+ if (isStreamMode && streamState.firstContentTimeMs !== null) {
+ const ttft = (streamState.firstContentTimeMs - startTimeMs) / 1000;
+ span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK, ttft);
+ }
+
+ if (streamState.toolDefinitions && streamState.toolDefinitions.length > 0) {
+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_DEFINITIONS, JSON.stringify(streamState.toolDefinitions));
+ }
+
+ const pricingInfo = OpenlitConfig.pricingInfo || {};
+ const effectiveModel = responseModel || requestModel;
+ const cost = effectiveModel
+ ? OpenLitHelper.getChatModelCost(effectiveModel, pricingInfo, usage.inputTokens, usage.outputTokens)
+ : 0;
+ if (cost) span.setAttribute(SemanticConvention.GEN_AI_USAGE_COST, cost);
+
+ let outputMessagesJson: string | null = null;
+ if (captureContent) {
+ const resultText = result?.result || run.result;
+ if (resultText && !streamState.assistantText) {
+ streamState.assistantText = resultText;
+ }
+ outputMessagesJson = buildOutputMessages(streamState, finishReason);
+ if (outputMessagesJson) {
+ span.setAttribute(SemanticConvention.GEN_AI_OUTPUT_MESSAGES, outputMessagesJson);
+ }
+ }
+
+ if (error) {
+ OpenLitHelper.handleException(span, error instanceof Error ? error : new Error(String(error)));
+ } else if (status === 'error') {
+ span.setAttribute(SemanticConvention.ERROR_TYPE, 'AgentError');
+ span.setStatus({ code: SpanStatusCode.ERROR, message: result?.result || 'agent error' });
+ } else {
+ span.setStatus({ code: SpanStatusCode.OK });
+ }
+
+ const inputMessagesJson = captureContent ? buildInputMessages(message) : null;
+ emitInvokeAgentEvent(
+ span, agentId, requestModel, responseModel, finishReason,
+ usage.inputTokens, usage.outputTokens, inputMessagesJson, outputMessagesJson,
+ );
+
+ recordInvokeAgentMetrics(
+ requestModel, usage.inputTokens, usage.outputTokens, cost, duration,
+ error ? (error.constructor?.name || '_OTHER') : (status === 'error' ? 'AgentError' : undefined),
+ );
+
+ span.end();
+ };
+
+ return new Proxy(run, {
+ get(target: any, prop: string | symbol, receiver: any) {
+ if (prop === 'stream') {
+ const originalStream = target.stream;
+ if (typeof originalStream !== 'function') return originalStream;
+
+ return function (...streamArgs: any[]) {
+ isStreamMode = true;
+ const generator = originalStream.apply(target, streamArgs);
+ return wrapAsyncGenerator(generator, toolTracker, streamState, finalizeSpan);
+ };
+ }
+
+ if (prop === 'wait') {
+ const originalWait = target.wait;
+ if (typeof originalWait !== 'function') return originalWait;
+
+ return function (...waitArgs: any[]) {
+ return originalWait.apply(target, waitArgs).then((result: any) => {
+ finalizeSpan(result);
+ return result;
+ }).catch((e: any) => {
+ finalizeSpan(undefined, e);
+ throw e;
+ });
+ };
+ }
+
+ if (prop === 'cancel') {
+ const originalCancel = target.cancel;
+ if (typeof originalCancel !== 'function') return originalCancel;
+
+ return function (...cancelArgs: any[]) {
+ return originalCancel.apply(target, cancelArgs).then((result: any) => {
+ finalizeSpan({ status: 'cancelled' });
+ return result;
+ });
+ };
+ }
+
+ return Reflect.get(target, prop, receiver);
+ },
+ });
+}
+
+// ---------------------------------------------------------------------------
+// wrapAsyncGenerator -- wraps run.stream() to intercept SDKMessage events
+// ---------------------------------------------------------------------------
+
+async function* wrapAsyncGenerator(
+ generator: AsyncGenerator<any>,
+ toolTracker: ToolSpanTracker,
+ streamState: StreamState,
+ finalizeSpan: (result?: any, error?: any) => void,
+): AsyncGenerator<any> {
+ try {
+ for await (const event of generator) {
+ try {
+ processStreamEvent(event, toolTracker, streamState);
+ } catch { /* swallow processing errors */ }
+ yield event;
+ }
+ finalizeSpan();
+ } catch (e: any) {
+ finalizeSpan(undefined, e);
+ throw e;
+ }
+}
+
+// ---------------------------------------------------------------------------
+// patchAgentCreate -- wraps Agent.create() for create_agent spans
+// ---------------------------------------------------------------------------
+
+export function patchAgentCreate(tracer: Tracer): (originalCreate: any) => any {
+ return (originalCreate: any) => {
+ return async function wrappedCreate(this: any, options: any) {
+ const agentName = resolveAgentName(options);
+ const modelId = resolveModelId(options);
+ const displayName = agentName || 'cursor-agent';
+ const spanName = `${SemanticConvention.GEN_AI_OPERATION_TYPE_CREATE_AGENT} ${displayName}`;
+
+ const span = tracer.startSpan(spanName, {
+ kind: SpanKind.CLIENT,
+ attributes: {
+ [SemanticConvention.GEN_AI_OPERATION]: SemanticConvention.GEN_AI_OPERATION_TYPE_CREATE_AGENT,
+ [SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL]: SemanticConvention.GEN_AI_SYSTEM_CURSOR,
+ [SemanticConvention.SERVER_ADDRESS]: SERVER_ADDRESS,
+ [SemanticConvention.SERVER_PORT]: SERVER_PORT,
+ },
+ });
+
+ setCommonSpanAttributes(span);
+ if (agentName) span.setAttribute(SemanticConvention.GEN_AI_AGENT_NAME, agentName);
+ if (modelId) span.setAttribute(SemanticConvention.GEN_AI_REQUEST_MODEL, modelId);
+
+ applyCustomSpanAttributes(span);
+
+ try {
+ const agent = await originalCreate.call(this, options);
+
+ const agentId = agent.agentId;
+ if (agentId) {
+ span.setAttribute(SemanticConvention.GEN_AI_AGENT_ID, agentId);
+ }
+ agentRegistry.register(agent, span.spanContext());
+
+ const resolvedModel = agent.model?.id || modelId;
+ if (resolvedModel) span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, resolvedModel);
+
+ span.setStatus({ code: SpanStatusCode.OK });
+ span.end();
+
+ if (typeof agent.send === 'function') {
+ const originalAgentSend = agent.send.bind(agent);
+ agent.send = wrapSend(tracer, originalAgentSend, agentId, agentName, resolvedModel);
+ }
+
+ return agent;
+ } catch (e: any) {
+ OpenLitHelper.handleException(span, e);
+ span.end();
+ throw e;
+ }
+ };
+ };
+}
+
+// ---------------------------------------------------------------------------
+// patchAgentResume -- wraps Agent.resume() to patch send() on resumed agents
+// ---------------------------------------------------------------------------
+
+export function patchAgentResume(tracer: Tracer): (originalResume: any) => any {
+ return (originalResume: any) => {
+ return async function wrappedResume(this: any, agentId: string, options?: any) {
+ const agentName = resolveAgentName(options);
+ const modelId = resolveModelId(options);
+
+ const agent = await originalResume.call(this, agentId, options);
+
+ const resolvedAgentId = agent.agentId || agentId;
+ const resolvedModel = agent.model?.id || modelId;
+
+ if (typeof agent.send === 'function') {
+ const originalAgentSend = agent.send.bind(agent);
+ agent.send = wrapSend(tracer, originalAgentSend, resolvedAgentId, agentName, resolvedModel);
+ }
+
+ return agent;
+ };
+ };
+}
+
diff --git a/sdk/typescript/src/instrumentation/index.ts b/sdk/typescript/src/instrumentation/index.ts
index b36764ee..f1d0ce32 100644
--- a/sdk/typescript/src/instrumentation/index.ts
+++ b/sdk/typescript/src/instrumentation/index.ts
@@ -26,6 +26,7 @@ import OpenAIAgentsInstrumentation from './openai-agents';
import StrandsInstrumentation from './strands';
import GoogleADKInstrumentation from './google-adk';
import ClaudeAgentSDKInstrumentation from './claude-agent-sdk';
+import CursorSDKInstrumentation from './cursor-sdk';
/**
* OTel community instrumentations loaded dynamically (like Python SDK).
@@ -94,6 +95,7 @@ export default class Instrumentations {
strands: new StrandsInstrumentation(),
'google-adk': new GoogleADKInstrumentation(),
'claude-agent-sdk': new ClaudeAgentSDKInstrumentation(),
+ 'cursor-sdk': new CursorSDKInstrumentation(),
};
static setup(
diff --git a/sdk/typescript/src/semantic-convention.ts b/sdk/typescript/src/semantic-convention.ts
index 5fc2319c..ddd11391 100644
--- a/sdk/typescript/src/semantic-convention.ts
+++ b/sdk/typescript/src/semantic-convention.ts
@@ -40,6 +40,8 @@ export default class SemanticConvention {
static GEN_AI_TOKEN_TYPE_REASONING = 'reasoning';
static GEN_AI_CLIENT_OPERATION_DURATION = 'gen_ai.client.operation.duration';
static GEN_AI_CLIENT_OPERATION_TIME_TO_FIRST_CHUNK = 'gen_ai.client.operation.time_to_first_chunk';
+ /** OTel standard span attribute for TTFT */
+ static GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK = 'gen_ai.response.time_to_first_chunk';
static GEN_AI_CLIENT_OPERATION_TIME_PER_OUTPUT_CHUNK = 'gen_ai.client.operation.time_per_output_chunk';
static GEN_AI_CLIENT_TOKEN_USAGE = 'gen_ai.client.token.usage';
static GEN_AI_SERVER_REQUEST_DURATION = 'gen_ai.server.request.duration';
@@ -77,6 +79,8 @@ export default class SemanticConvention {
// GenAI Request (extended / OpenLIT)
static GEN_AI_REQUEST_IS_STREAM = 'gen_ai.request.is_stream';
+ /** OTel standard: gen_ai.request.stream (replaces gen_ai.request.is_stream) */
+ static GEN_AI_REQUEST_STREAM = 'gen_ai.request.stream';
static GEN_AI_REQUEST_USER = 'gen_ai.request.user';
static GEN_AI_REQUEST_EMBEDDING_DIMENSION = 'gen_ai.request.embedding_dimension';
static GEN_AI_REQUEST_TOOL_CHOICE = 'gen_ai.request.tool_choice';
@@ -226,6 +230,7 @@ export default class SemanticConvention {
static GEN_AI_SYSTEM_CLAUDE_AGENT_SDK = 'claude_agent_sdk';
static GEN_AI_SYSTEM_GOOGLE_ADK = 'google_adk';
static GEN_AI_SYSTEM_STRANDS = 'strands_agents';
+ static GEN_AI_SYSTEM_CURSOR = 'cursor';
static GEN_AI_OPERATION_TYPE_CREATE_AGENT = 'create_agent';
diff --git a/sdk/typescript/src/types.ts b/sdk/typescript/src/types.ts
index a74caafd..84007e40 100644
--- a/sdk/typescript/src/types.ts
+++ b/sdk/typescript/src/types.ts
@@ -2,7 +2,7 @@ import { Resource } from '@opentelemetry/resources';
import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
import { metrics } from '@opentelemetry/api';
-export type InstrumentationType = 'openai' | 'anthropic' | 'cohere' | 'groq' | 'mistral' | 'google-ai' | 'together' | 'ollama' | 'vercel-ai' | 'langchain' | 'langgraph' | 'pinecone' | 'bedrock' | 'llamaindex' | 'huggingface' | 'replicate' | 'chroma' | 'qdrant' | 'milvus' | 'azure-ai-inference' | 'openai-agents' | 'strands' | 'google-adk' | 'claude-agent-sdk';
+export type InstrumentationType = 'openai' | 'anthropic' | 'cohere' | 'groq' | 'mistral' | 'google-ai' | 'together' | 'ollama' | 'vercel-ai' | 'langchain' | 'langgraph' | 'pinecone' | 'bedrock' | 'llamaindex' | 'huggingface' | 'replicate' | 'chroma' | 'qdrant' | 'milvus' | 'azure-ai-inference' | 'openai-agents' | 'strands' | 'google-adk' | 'claude-agent-sdk' | 'cursor-sdk';
export type OpenlitInstrumentations = Partial<Record<InstrumentationType, any>>;
diff --git a/sdk/typescript/test-cursor.ts b/sdk/typescript/test-cursor.ts
new file mode 100644
index 00000000..5da25a91
--- /dev/null
+++ b/sdk/typescript/test-cursor.ts
@@ -0,0 +1,45 @@
+import openlit from './src/index';
+import { Agent } from '@cursor/sdk';
+
+async function main() {
+ openlit.init({
+ captureMessageContent: true,
+ });
+
+ console.log('--- Agent.create() + agent.send() + stream ---');
+ const agent = await Agent.create({
+ apiKey: process.env.CURSOR_API_KEY!,
+ model: { id: 'composer-2' },
+ local: { cwd: process.cwd() },
+ });
+
+ const run = await agent.send('What is 2 + 2? Reply in one word.');
+
+ for await (const event of run.stream()) {
+ if (event.type === 'assistant') {
+ for (const block of event.message.content) {
+ if (block.type === 'text') process.stdout.write(block.text);
+ }
+ } else if (event.type === 'tool_call') {
+ console.log(`[tool] ${event.name} (${event.status})`);
+ }
+ }
+ console.log('\n');
+
+ console.log('--- Agent.prompt() one-shot ---');
+ const result = await Agent.prompt('What is 3 + 3? Reply in one word.', {
+ apiKey: process.env.CURSOR_API_KEY!,
+ model: { id: 'composer-2' },
+ local: { cwd: process.cwd() },
+ });
+ console.log('Result:', result.result);
+ console.log('Status:', result.status);
+
+ agent.close();
+
+ // Give the OTel exporter time to flush spans
+ await new Promise(resolve => setTimeout(resolve, 5000));
+ console.log('\nDone. Check your OTel collector for spans.');
+}
+
+main().catch(console.error);