@latitude-data/telemetry 3.0.0-alpha.0 → 3.0.0-alpha.2

package/dist/index.js

@@ -1,3 +1,165 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/sdk/context.ts
+import { context, createContextKey, trace } from "@opentelemetry/api";
+var LATITUDE_CONTEXT_KEY = createContextKey("latitude-internal-context");
+var CAPTURE_TRACER_NAME = "so.latitude.instrumentation.capture";
+function getLatitudeContext(ctx) {
+  return ctx.getValue(LATITUDE_CONTEXT_KEY);
+}
+function mergeArrays(a, b) {
+  if (!a && !b) return void 0;
+  if (!a) return b;
+  if (!b) return a;
+  return [.../* @__PURE__ */ new Set([...a, ...b])];
+}
+function capture(name, fn, options = {}) {
+  const currentContext = context.active();
+  const existingData = getLatitudeContext(currentContext);
+  const mergedData = {
+    name: options.name ?? name,
+    tags: mergeArrays(existingData?.tags, options.tags),
+    metadata: { ...existingData?.metadata, ...options.metadata },
+    sessionId: options.sessionId ?? existingData?.sessionId,
+    userId: options.userId ?? existingData?.userId
+  };
+  const newContext = currentContext.setValue(LATITUDE_CONTEXT_KEY, mergedData);
+  const existingSpan = trace.getSpan(currentContext);
+  if (existingSpan) {
+    return context.with(newContext, fn);
+  }
+  const tracer = trace.getTracer(CAPTURE_TRACER_NAME);
+  return tracer.startActiveSpan(name, { attributes: { "latitude.capture.root": true } }, newContext, (span) => {
+    let result;
+    try {
+      result = fn();
+    } catch (error) {
+      span.recordException(error);
+      span.end();
+      throw error;
+    }
+    if (result instanceof Promise) {
+      return result.catch((error) => {
+        span.recordException(error);
+        throw error;
+      }).finally(() => {
+        span.end();
+      });
+    }
+    span.end();
+    return result;
+  });
+}
+
+// src/sdk/init.ts
+import { context as context2, propagation } from "@opentelemetry/api";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { CompositePropagator, W3CBaggagePropagator, W3CTraceContextPropagator } from "@opentelemetry/core";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+
+// src/sdk/instrumentations.ts
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { AnthropicInstrumentation } from "@traceloop/instrumentation-anthropic";
+import { BedrockInstrumentation } from "@traceloop/instrumentation-bedrock";
+import { CohereInstrumentation } from "@traceloop/instrumentation-cohere";
+import { LangChainInstrumentation } from "@traceloop/instrumentation-langchain";
+import { LlamaIndexInstrumentation } from "@traceloop/instrumentation-llamaindex";
+import { OpenAIInstrumentation } from "@traceloop/instrumentation-openai";
+import { TogetherInstrumentation } from "@traceloop/instrumentation-together";
+import { AIPlatformInstrumentation, VertexAIInstrumentation } from "@traceloop/instrumentation-vertexai";
+var INSTRUMENTATION_MAP = {
+  openai: { ctor: OpenAIInstrumentation, moduleName: "openai", defaultEnrichTokens: true },
+  anthropic: { ctor: AnthropicInstrumentation, moduleName: "@anthropic-ai/sdk" },
+  bedrock: { ctor: BedrockInstrumentation, moduleName: "@aws-sdk/client-bedrock-runtime" },
+  cohere: { ctor: CohereInstrumentation, moduleName: "cohere-ai" },
+  langchain: { ctor: LangChainInstrumentation, moduleName: "langchain" },
+  llamaindex: { ctor: LlamaIndexInstrumentation, moduleName: "llamaindex" },
+  togetherai: { ctor: TogetherInstrumentation, moduleName: "together-ai", defaultEnrichTokens: false },
+  vertexai: { ctor: VertexAIInstrumentation, moduleName: "@google-cloud/vertexai" },
+  aiplatform: { ctor: AIPlatformInstrumentation, moduleName: "@google-cloud/aiplatform" }
+};
+async function createLatitudeInstrumentations(options) {
+  const result = [];
+  for (const type of options.instrumentations) {
+    const config = INSTRUMENTATION_MAP[type];
+    if (!config) {
+      console.warn(`[Latitude] Unknown instrumentation type: ${type}`);
+      continue;
+    }
+    const enrichTokens = options.enrichTokens?.[type] ?? config.defaultEnrichTokens;
+    const inst = new config.ctor(enrichTokens !== void 0 ? { enrichTokens } : void 0);
+    const moduleRef = options.modules?.[type] ?? await tryRequire(config.moduleName);
+    if (!moduleRef) {
+      console.warn(
+        `[Latitude] Module not found for ${type}: ${config.moduleName}. Install it or pass it explicitly in 'modules'.`
+      );
+      continue;
+    }
+    inst.manuallyInstrument?.(moduleRef);
+    result.push(inst);
+  }
+  return result;
+}
+async function tryRequire(moduleName) {
+  try {
+    return __require(moduleName);
+  } catch {
+    try {
+      const mod = await import(moduleName);
+      return mod.default ?? mod;
+    } catch {
+      return void 0;
+    }
+  }
+}
+async function registerLatitudeInstrumentations(options) {
+  const instrumentations = await createLatitudeInstrumentations(options);
+  registerInstrumentations({
+    instrumentations,
+    tracerProvider: options.tracerProvider
+  });
+}
+
+// src/sdk/processor.ts
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import {
+  BatchSpanProcessor,
+  SimpleSpanProcessor
+} from "@opentelemetry/sdk-trace-node";
+
+// src/constants/attributes.ts
+var ATTRIBUTES = {
+  name: "latitude.capture.name",
+  tags: "latitude.tags",
+  metadata: "latitude.metadata",
+  sessionId: "session.id",
+  userId: "user.id"
+};
+
+// src/constants/scope.ts
+var SCOPE_LATITUDE = "so.latitude.instrumentation";
+
+// src/env/env.ts
+var DEFAULT_EXPORTER_URL = {
+  production: "https://ingest.latitude.so",
+  development: "http://localhost:3002",
+  test: "http://localhost:3002"
+}[process.env.NODE_ENV ?? "development"] ?? "http://localhost:3002";
+function getExporterUrl() {
+  if (process.env.LATITUDE_TELEMETRY_URL) {
+    return process.env.LATITUDE_TELEMETRY_URL;
+  }
+  return DEFAULT_EXPORTER_URL;
+}
+var env = { EXPORTER_URL: getExporterUrl() };
+
 // src/sdk/redact.ts
 var RedactSpanProcessor = class {
   options;
@@ -48,349 +210,276 @@ var RedactSpanProcessor = class {
 };
 var DEFAULT_REDACT_SPAN_PROCESSOR = () => new RedactSpanProcessor({
   attributes: [
+    // HTTP security headers
     /^http\.request\.header\.authorization$/i,
     /^http\.request\.header\.cookie$/i,
     /^http\.request\.header\.x[-_]api[-_]key$/i,
+    // Database statements may contain sensitive data
     /^db\.statement$/i
   ]
 });
 
-// src/sdk/sdk.ts
-import * as otel2 from "@opentelemetry/api";
-import { context, propagation as propagation2 } from "@opentelemetry/api";
-import { ALLOW_ALL_BAGGAGE_KEYS, BaggageSpanProcessor } from "@opentelemetry/baggage-span-processor";
-import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
-import { CompositePropagator, W3CBaggagePropagator, W3CTraceContextPropagator } from "@opentelemetry/core";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { registerInstrumentations } from "@opentelemetry/instrumentation";
-import { Resource } from "@opentelemetry/resources";
-import {
-  BatchSpanProcessor,
-  NodeTracerProvider,
-  SimpleSpanProcessor
-} from "@opentelemetry/sdk-trace-node";
-import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
-import { AnthropicInstrumentation } from "@traceloop/instrumentation-anthropic";
-import { BedrockInstrumentation } from "@traceloop/instrumentation-bedrock";
-import { CohereInstrumentation } from "@traceloop/instrumentation-cohere";
-import { LangChainInstrumentation } from "@traceloop/instrumentation-langchain";
-import { LlamaIndexInstrumentation } from "@traceloop/instrumentation-llamaindex";
-import { OpenAIInstrumentation } from "@traceloop/instrumentation-openai";
-import { TogetherInstrumentation } from "@traceloop/instrumentation-together";
-import { AIPlatformInstrumentation, VertexAIInstrumentation } from "@traceloop/instrumentation-vertexai";
-
-// src/constants/attributes.ts
-var ATTRIBUTES = {
-  tags: "latitude.tags",
-  metadata: "latitude.metadata",
-  sessionId: "session.id",
-  userId: "user.id"
-};
-
-// src/constants/scope.ts
-var SCOPE_LATITUDE = "so.latitude.instrumentation";
-
-// src/env/env.ts
-var DEFAULT_EXPORTER_URL = {
-  production: "https://ingest.latitude.so",
-  development: "http://localhost:3002",
-  test: "http://localhost:3002"
-}[process.env.NODE_ENV ?? "development"] ?? "http://localhost:3002";
-function getExporterUrl() {
-  if (process.env.LATITUDE_TELEMETRY_URL) {
-    return process.env.LATITUDE_TELEMETRY_URL;
-  }
-  return DEFAULT_EXPORTER_URL;
+// src/sdk/span-filter.ts
+var GEN_AI_PREFIX = "gen_ai.";
+var LLM_PREFIX = "llm.";
+var OPENINFERENCE_KIND = "openinference.span.kind";
+var OTEL_LLM_INSTRUMENTATION_SCOPE_PREFIXES = [
+  "opentelemetry.instrumentation.alephalpha",
+  "opentelemetry.instrumentation.anthropic",
+  "opentelemetry.instrumentation.bedrock",
+  "opentelemetry.instrumentation.cohere",
+  "opentelemetry.instrumentation.crewai",
+  "opentelemetry.instrumentation.google_generativeai",
+  "opentelemetry.instrumentation.groq",
+  "opentelemetry.instrumentation.haystack",
+  "opentelemetry.instrumentation.langchain",
+  "opentelemetry.instrumentation.llamaindex",
+  "opentelemetry.instrumentation.mistralai",
+  "opentelemetry.instrumentation.ollama",
+  "opentelemetry.instrumentation.openai",
+  "opentelemetry.instrumentation.replicate",
+  "opentelemetry.instrumentation.sagemaker",
+  "opentelemetry.instrumentation.together",
+  "opentelemetry.instrumentation.transformers",
+  "opentelemetry.instrumentation.vertexai",
+  "opentelemetry.instrumentation.watsonx",
+  "openinference.instrumentation"
+];
+var LLM_SCOPE_SUBSTRINGS = ["openinference", "traceloop", "langsmith", "litellm"];
+function buildShouldExportSpanFromFields(fields) {
+  return buildShouldExportSpan({
+    ...fields.disableSmartFilter !== void 0 ? { disableSmartFilter: fields.disableSmartFilter } : {},
+    ...fields.shouldExportSpan !== void 0 ? { shouldExportSpan: fields.shouldExportSpan } : {},
+    ...fields.blockedInstrumentationScopes !== void 0 ? { blockedInstrumentationScopes: fields.blockedInstrumentationScopes } : {}
+  });
 }
-var env = { EXPORTER_URL: getExporterUrl() };
-
-// src/instrumentations/manual.ts
-import * as otel from "@opentelemetry/api";
-import { propagation, trace } from "@opentelemetry/api";
-var ManualInstrumentation = class {
-  enabled;
-  _tracer;
-  constructor(tracer) {
-    this.enabled = false;
-    this._tracer = tracer;
-  }
-  get tracer() {
-    return this._tracer;
-  }
-  isEnabled() {
-    return this.enabled;
-  }
-  enable() {
-    this.enabled = true;
-  }
-  disable() {
-    this.enabled = false;
-  }
-  resume(ctx) {
-    const parts = ctx.traceparent.split("-");
-    if (parts.length !== 4) {
-      return otel.ROOT_CONTEXT;
-    }
-    const [, traceId, spanId, flags] = parts;
-    if (!traceId || !spanId) {
-      return otel.ROOT_CONTEXT;
-    }
-    const spanContext = {
-      traceId,
-      spanId,
-      traceFlags: parseInt(flags ?? "01", 16),
-      isRemote: true
-    };
-    let context2 = trace.setSpanContext(otel.ROOT_CONTEXT, spanContext);
-    if (ctx.baggage) {
-      const baggageEntries = {};
-      for (const pair of ctx.baggage.split(",")) {
-        const [key, value] = pair.split("=", 2);
-        if (key && value) {
-          baggageEntries[decodeURIComponent(key)] = { value: decodeURIComponent(value) };
-        }
-      }
-      const baggage = propagation.createBaggage(baggageEntries);
-      context2 = propagation.setBaggage(context2, baggage);
-    }
-    return context2;
+function attributeKeys(span) {
+  const attrs = span.attributes;
+  if (!attrs || typeof attrs !== "object") return [];
+  return Object.keys(attrs);
+}
+function instrumentationScopeName(span) {
+  return span.instrumentationScope?.name ?? "";
+}
+function isGenAiOrLlmAttributeSpan(span) {
+  for (const key of attributeKeys(span)) {
+    if (key.startsWith(GEN_AI_PREFIX) || key.startsWith(LLM_PREFIX)) return true;
+    if (key === OPENINFERENCE_KIND || key.startsWith("openinference.")) return true;
+    if (key.startsWith("ai.")) return true;
+    if (key.startsWith("latitude.")) return true;
+  }
+  return false;
+}
+function isLatitudeInstrumentationSpan(span) {
+  const name = instrumentationScopeName(span);
+  return name === SCOPE_LATITUDE || name.startsWith(`${SCOPE_LATITUDE}.`);
+}
+function isKnownLlmInstrumentationScope(span) {
+  const name = instrumentationScopeName(span);
+  if (!name) return false;
+  for (const prefix of OTEL_LLM_INSTRUMENTATION_SCOPE_PREFIXES) {
+    if (name === prefix || name.startsWith(`${prefix}.`)) return true;
   }
-};
-
-// src/sdk/sdk.ts
-var TRACES_URL = `${env.EXPORTER_URL}/v1/traces`;
-var SERVICE_NAME = process.env.npm_package_name || "unknown";
-var SCOPE_VERSION = process.env.npm_package_version || "unknown";
-var ContextManager = class {
-  telemetry;
-  constructor(telemetry) {
-    this.telemetry = telemetry;
+  const lower = name.toLowerCase();
+  for (const part of LLM_SCOPE_SUBSTRINGS) {
+    if (lower.includes(part)) return true;
   }
-  resume(ctx) {
-    return this.telemetry.resume(ctx);
+  return false;
+}
+function isDefaultExportSpan(span) {
+  if (isLatitudeInstrumentationSpan(span)) return true;
+  if (isGenAiOrLlmAttributeSpan(span)) return true;
+  if (isKnownLlmInstrumentationScope(span)) return true;
+  return false;
+}
+function buildShouldExportSpan(options) {
+  if (options.disableSmartFilter) return () => true;
+  const blocked = new Set(options.blockedInstrumentationScopes ?? []);
+  const extra = options.shouldExportSpan;
+  return (span) => {
+    const scope = instrumentationScopeName(span);
+    if (blocked.has(scope)) return false;
+    if (isDefaultExportSpan(span)) return true;
+    if (extra?.(span)) return true;
+    return false;
+  };
+}
+var ExportFilterSpanProcessor = class {
+  shouldExport;
+  inner;
+  constructor(shouldExport, inner) {
+    this.shouldExport = shouldExport;
+    this.inner = inner;
   }
-  active() {
-    return context.active();
+  onStart(span, parentContext) {
+    this.inner.onStart(span, parentContext);
   }
-  with(ctx, fn, thisArg, ...args) {
-    return context.with(ctx, fn, thisArg, ...args);
+  onEnd(span) {
+    if (!this.shouldExport(span)) return;
+    this.inner.onEnd(span);
   }
-};
-var InstrumentationManager = class {
-  instrumentations;
-  constructor(instrumentations) {
-    this.instrumentations = instrumentations;
-  }
-  enable() {
-    for (const instrumentation of this.instrumentations) {
-      if (!instrumentation.isEnabled()) instrumentation.enable();
-    }
+  forceFlush() {
+    return this.inner.forceFlush();
   }
-  disable() {
-    for (const instrumentation of this.instrumentations) {
-      if (instrumentation.isEnabled()) instrumentation.disable();
-    }
+  shutdown() {
+    return this.inner.shutdown();
   }
 };
-var TracerManager = class {
-  nodeProvider;
-  scopeVersion;
-  constructor(nodeProvider, scopeVersion) {
-    this.nodeProvider = nodeProvider;
-    this.scopeVersion = scopeVersion;
+var RedactThenExportSpanProcessor = class {
+  redact;
+  exportProcessor;
+  constructor(redact, exportProcessor) {
+    this.redact = redact;
+    this.exportProcessor = exportProcessor;
   }
-  get(scope) {
-    return this.provider(scope).getTracer("");
+  onStart(span, parentContext) {
+    this.redact?.onStart(span, parentContext);
+    this.exportProcessor.onStart(span, parentContext);
   }
-  provider(scope) {
-    return new ScopedTracerProvider(`${SCOPE_LATITUDE}.${scope}`, this.scopeVersion, this.nodeProvider);
-  }
-};
-var ScopedTracerProvider = class {
-  scope;
-  version;
-  provider;
-  constructor(scope, version, provider) {
-    this.scope = scope;
-    this.version = version;
-    this.provider = provider;
-  }
-  getTracer(_name, _version, options) {
-    return this.provider.getTracer(this.scope, this.version, options);
-  }
-};
-var LifecycleManager = class {
-  nodeProvider;
-  exporter;
-  constructor(nodeProvider, exporter) {
-    this.nodeProvider = nodeProvider;
-    this.exporter = exporter;
+  onEnd(span) {
+    this.redact?.onEnd(span);
+    this.exportProcessor.onEnd(span);
   }
-  async flush() {
-    await this.nodeProvider.forceFlush();
-    await this.exporter.forceFlush?.();
+  forceFlush() {
+    return this.exportProcessor.forceFlush();
   }
-  async shutdown() {
-    await this.flush();
-    await this.nodeProvider.shutdown();
-    await this.exporter.shutdown?.();
+  shutdown() {
+    return this.exportProcessor.shutdown();
   }
 };
-var DEFAULT_SPAN_EXPORTER = (apiKey, projectSlug) => new OTLPTraceExporter({
-  url: TRACES_URL,
-  headers: {
-    Authorization: `Bearer ${apiKey}`,
-    "Content-Type": "application/json",
-    "X-Latitude-Project": projectSlug
-  },
-  timeoutMillis: 30 * 1e3
-});
-var Instrumentation = /* @__PURE__ */ ((Instrumentation2) => {
-  Instrumentation2["Anthropic"] = "anthropic";
-  Instrumentation2["AIPlatform"] = "aiplatform";
-  Instrumentation2["Bedrock"] = "bedrock";
-  Instrumentation2["Cohere"] = "cohere";
-  Instrumentation2["Langchain"] = "langchain";
-  Instrumentation2["LlamaIndex"] = "llamaindex";
-  Instrumentation2["Manual"] = "manual";
-  Instrumentation2["OpenAI"] = "openai";
-  Instrumentation2["TogetherAI"] = "togetherai";
-  Instrumentation2["VertexAI"] = "vertexai";
-  return Instrumentation2;
-})(Instrumentation || {});
-var LatitudeTelemetry = class {
-  options;
-  nodeProvider;
-  instrumentationsList;
-  /** OpenTelemetry tracer for creating custom spans. */
-  tracer;
-  context;
-  instrumentation;
-  lifecycle;
+
+// src/sdk/processor.ts
+var LatitudeSpanProcessor = class {
+  tail;
   constructor(apiKey, projectSlug, options) {
-    this.options = options || {};
-    if (!this.options.exporter) {
-      this.options.exporter = DEFAULT_SPAN_EXPORTER(apiKey, projectSlug);
-    }
-    context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable());
-    propagation2.setGlobalPropagator(
-      new CompositePropagator({
-        propagators: [...this.options.propagators || [], new W3CTraceContextPropagator(), new W3CBaggagePropagator()]
-      })
-    );
-    const spanProcessors = [
-      // Must run before the exporter span processors
-      new BaggageSpanProcessor(ALLOW_ALL_BAGGAGE_KEYS),
-      ...this.options.processors ?? [DEFAULT_REDACT_SPAN_PROCESSOR()],
-      this.options.disableBatch ? new SimpleSpanProcessor(this.options.exporter) : new BatchSpanProcessor(this.options.exporter)
-    ];
-    this.nodeProvider = new NodeTracerProvider({
-      resource: new Resource({ [ATTR_SERVICE_NAME]: this.options.serviceName || SERVICE_NAME }),
-      spanProcessors
-    });
-    this.lifecycle = new LifecycleManager(this.nodeProvider, this.options.exporter);
-    this.nodeProvider.register();
-    process.on("SIGTERM", () => this.shutdown());
-    process.on("SIGINT", () => this.shutdown());
-    this.instrumentationsList = [];
-    const tracerManager = new TracerManager(this.nodeProvider, SCOPE_VERSION);
-    const manualTracer = tracerManager.get("manual" /* Manual */);
-    const manualInstrumentation = new ManualInstrumentation(manualTracer);
-    this.instrumentationsList.push(manualInstrumentation);
-    this.tracer = manualTracer;
-    this.initProviderInstrumentations(tracerManager);
-    this.instrumentation = new InstrumentationManager(this.instrumentationsList);
-    this.instrumentation.enable();
-    this.context = new ContextManager(manualInstrumentation);
-  }
-  async flush() {
-    await this.lifecycle.flush();
-  }
-  async shutdown() {
-    await this.lifecycle.shutdown();
-  }
-  initProviderInstrumentations(tracerManager) {
-    const configure = (type, Ctor, opts) => {
-      const providerPkg = this.options.instrumentations?.[type];
-      if (!providerPkg) return;
-      const provider = tracerManager.provider(type);
-      const inst = new Ctor(opts);
-      inst.setTracerProvider(provider);
-      inst.manuallyInstrument(providerPkg);
-      registerInstrumentations({
-        instrumentations: [inst],
-        tracerProvider: provider
-      });
-      this.instrumentationsList.push(inst);
-    };
-    configure("anthropic" /* Anthropic */, AnthropicInstrumentation);
-    configure("aiplatform" /* AIPlatform */, AIPlatformInstrumentation);
-    configure("bedrock" /* Bedrock */, BedrockInstrumentation);
-    configure("cohere" /* Cohere */, CohereInstrumentation);
-    configure("langchain" /* Langchain */, LangChainInstrumentation);
-    configure("llamaindex" /* LlamaIndex */, LlamaIndexInstrumentation);
-    configure("openai" /* OpenAI */, OpenAIInstrumentation, { enrichTokens: true });
-    configure("togetherai" /* TogetherAI */, TogetherInstrumentation, { enrichTokens: false });
-    configure("vertexai" /* VertexAI */, VertexAIInstrumentation);
-  }
-  /**
-   * Wrap a block of code with trace-wide context attributes.
-   * Baggage entries (tags, metadata, sessionId, userId) are propagated
-   * to all spans created within the callback via BaggageSpanProcessor.
-   *
-   * If there is no active span, a root span is created so all child spans
-   * are grouped under a single trace. If a span is already active, only
-   * baggage is set without creating an extra wrapper span.
-   */
-  async capture(options, fn) {
-    const baggageEntries = {};
-    if (options.tags?.length) {
-      baggageEntries[ATTRIBUTES.tags] = { value: JSON.stringify(options.tags) };
-    }
-    if (options.metadata) {
-      baggageEntries[ATTRIBUTES.metadata] = { value: JSON.stringify(options.metadata) };
-    }
-    if (options.sessionId) {
-      baggageEntries[ATTRIBUTES.sessionId] = { value: options.sessionId };
+    if (!apiKey || apiKey.trim() === "") {
+      throw new Error("[Latitude] apiKey is required and cannot be empty");
     }
-    if (options.userId) {
-      baggageEntries[ATTRIBUTES.userId] = { value: options.userId };
+    if (!projectSlug || projectSlug.trim() === "") {
+      throw new Error("[Latitude] projectSlug is required and cannot be empty");
     }
-    const baggage = propagation2.createBaggage(baggageEntries);
-    const activeSpan = otel2.trace.getSpan(context.active());
-    if (activeSpan) {
-      const ctx = propagation2.setBaggage(context.active(), baggage);
-      return await context.with(ctx, async () => await fn(ctx));
-    }
-    const rootContext = propagation2.setBaggage(otel2.ROOT_CONTEXT, baggage);
-    return await this.tracer.startActiveSpan(
-      "latitude.trace",
-      { kind: otel2.SpanKind.INTERNAL },
-      rootContext,
-      async (span) => {
-        try {
-          const result = await fn(context.active());
-          span.setStatus({ code: otel2.SpanStatusCode.OK });
-          return result;
-        } catch (error) {
-          span.setStatus({
-            code: otel2.SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-          });
-          span.recordException(error instanceof Error ? error : new Error(String(error)));
-          throw error;
-        } finally {
-          span.end();
+    const exporter = options?.exporter ?? new OTLPTraceExporter({
+      url: `${env.EXPORTER_URL}/v1/traces`,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "X-Latitude-Project": projectSlug
+      },
+      timeoutMillis: 3e4
+    });
+    const redact = options?.disableRedact ? null : options?.redact ? new RedactSpanProcessor(options.redact) : DEFAULT_REDACT_SPAN_PROCESSOR();
+    const batchOrSimple = options?.disableBatch ? new SimpleSpanProcessor(exporter) : new BatchSpanProcessor(exporter);
+    const shouldExport = buildShouldExportSpanFromFields({
+      disableSmartFilter: options?.disableSmartFilter,
+      shouldExportSpan: options?.shouldExportSpan,
+      blockedInstrumentationScopes: options?.blockedInstrumentationScopes
+    });
+    const redactThenExport = new RedactThenExportSpanProcessor(redact, batchOrSimple);
+    this.tail = new ExportFilterSpanProcessor(shouldExport, redactThenExport);
+  }
+  onStart(span, parentContext) {
+    const latitudeData = getLatitudeContext(parentContext);
+    if (latitudeData) {
+      if (latitudeData.name) {
+        span.setAttribute(ATTRIBUTES.name, latitudeData.name);
+        if (span.attributes["latitude.capture.root"]) {
+          span.updateName(latitudeData.name);
         }
       }
-    );
+      if (latitudeData.tags && latitudeData.tags.length > 0) {
+        span.setAttribute(ATTRIBUTES.tags, JSON.stringify(latitudeData.tags));
+      }
+      if (latitudeData.metadata && Object.keys(latitudeData.metadata).length > 0) {
+        span.setAttribute(ATTRIBUTES.metadata, JSON.stringify(latitudeData.metadata));
+      }
+      if (latitudeData.sessionId) {
+        span.setAttribute(ATTRIBUTES.sessionId, latitudeData.sessionId);
+      }
+      if (latitudeData.userId) {
+        span.setAttribute(ATTRIBUTES.userId, latitudeData.userId);
+      }
+    }
+    this.tail.onStart(span, parentContext);
+  }
+  onEnd(span) {
+    this.tail.onEnd(span);
+  }
+  async forceFlush() {
+    await this.tail.forceFlush();
+  }
+  async shutdown() {
+    await this.tail.shutdown();
   }
 };
+
+// src/sdk/init.ts
+var SERVICE_NAME = process.env.npm_package_name || "unknown";
+var shutdownHandlersRegistered = false;
+function initLatitude(options) {
+  const { apiKey, projectSlug, instrumentations = [], ...processorOptions } = options;
+  if (!apiKey || apiKey.trim() === "") {
+    throw new Error("[Latitude] apiKey is required and cannot be empty");
+  }
+  if (!projectSlug || projectSlug.trim() === "") {
+    throw new Error("[Latitude] projectSlug is required and cannot be empty");
+  }
+  const contextManager = new AsyncLocalStorageContextManager();
+  contextManager.enable();
+  const propagator = new CompositePropagator({
+    propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()]
+  });
+  context2.setGlobalContextManager(contextManager);
+  propagation.setGlobalPropagator(propagator);
+  const provider = new NodeTracerProvider({
+    resource: resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: SERVICE_NAME
+    }),
+    spanProcessors: [new LatitudeSpanProcessor(apiKey, projectSlug, processorOptions)]
+  });
+  provider.register();
+  const ready = registerLatitudeInstrumentations({
+    instrumentations,
+    tracerProvider: provider
+  }).catch((err) => {
+    console.warn("[Latitude] Failed to register instrumentations:", err);
+  });
+  const shutdown = async () => {
+    await provider.shutdown();
+  };
+  const flush = async () => {
+    await provider.forceFlush();
+  };
+  const handleShutdown = async () => {
+    try {
+      await shutdown();
+    } catch (err) {
+      console.error("Error during Latitude Telemetry shutdown:", err);
+    }
+  };
+  if (!shutdownHandlersRegistered) {
+    process.once("SIGTERM", handleShutdown);
+    process.once("SIGINT", handleShutdown);
+    shutdownHandlersRegistered = true;
+  }
+  return {
+    provider,
+    flush,
+    shutdown,
+    ready
+  };
+}
 export {
-  DEFAULT_REDACT_SPAN_PROCESSOR,
-  DEFAULT_SPAN_EXPORTER,
-  Instrumentation,
-  LatitudeTelemetry,
-  RedactSpanProcessor
+  ExportFilterSpanProcessor,
+  LatitudeSpanProcessor,
+  RedactSpanProcessor,
+  RedactThenExportSpanProcessor,
+  buildShouldExportSpan,
+  buildShouldExportSpanFromFields,
+  capture,
+  initLatitude,
+  isDefaultExportSpan,
+  isGenAiOrLlmAttributeSpan,
+  isLatitudeInstrumentationSpan,
+  registerLatitudeInstrumentations
 };
 //# sourceMappingURL=index.js.map