raindrop-ai 0.0.73 → 0.0.74-otelv2

package/dist/chunk-VLA74EMW.mjs

@@ -0,0 +1,424 @@
+// src/tracing/tracer-core.ts
+import { context, trace as trace2 } from "@opentelemetry/api";
+import { AnthropicInstrumentation } from "@traceloop/instrumentation-anthropic";
+import { BedrockInstrumentation } from "@traceloop/instrumentation-bedrock";
+import { ChromaDBInstrumentation } from "@traceloop/instrumentation-chromadb";
+import { CohereInstrumentation } from "@traceloop/instrumentation-cohere";
+import { OpenAIInstrumentation } from "@traceloop/instrumentation-openai";
+import { PineconeInstrumentation } from "@traceloop/instrumentation-pinecone";
+import { QdrantInstrumentation } from "@traceloop/instrumentation-qdrant";
+import { TogetherInstrumentation } from "@traceloop/instrumentation-together";
+import {
+  AIPlatformInstrumentation,
+  VertexAIInstrumentation
+} from "@traceloop/instrumentation-vertexai";
+import * as traceloop3 from "@traceloop/node-server-sdk";
+import { WeakValueMap } from "weakref";
+
+// src/tracing/liveInteraction.ts
+import { trace } from "@opentelemetry/api";
+import * as traceloop from "@traceloop/node-server-sdk";
+function getPropertiesFromContext(context2) {
+  const properties = {
+    ...context2.userId && { user_id: context2.userId },
+    ...context2.convoId && { convo_id: context2.convoId },
+    ...context2.eventId && { event_id: context2.eventId },
+    ...context2.properties || {}
+  };
+  if (context2.attachments && context2.attachments.length > 0) {
+    properties.attachments = JSON.stringify(context2.attachments);
+  }
+  return properties;
+}
+var LiveInteraction = class {
+  constructor(context2, traceId, analytics) {
+    this.context = context2;
+    this.analytics = analytics;
+    this.tracer = trace.getTracer("traceloop.tracer");
+    this.traceId = traceId;
+  }
+  async withSpan(params, fn, thisArg, ...args) {
+    var _a;
+    const taskName = typeof params === "string" ? params : params.name;
+    const properties = typeof params === "string" ? {
+      ...getPropertiesFromContext(this.context)
+    } : {
+      ...getPropertiesFromContext(this.context),
+      ...params.properties || {}
+    };
+    const inputParameters = typeof params === "string" ? void 0 : params.inputParameters;
+    if ((_a = this.analytics) == null ? void 0 : _a.debugLogs) {
+      console.log("[raindrop] using withSpan in liveInteraction");
+    }
+    return traceloop.withTask(
+      {
+        name: taskName,
+        associationProperties: properties,
+        inputParameters,
+        traceContent: params.traceContent,
+        suppressTracing: params.suppressTracing
+      },
+      fn,
+      thisArg,
+      ...args
+    );
+  }
+  async withTool(params, fn, thisArg, ...args) {
+    var _a;
+    const toolName = params.name;
+    const properties = {
+      ...getPropertiesFromContext(this.context),
+      ...params.properties || {}
+    };
+    const inputParams = params.inputParameters ? [params.inputParameters] : void 0;
+    if ((_a = this.analytics) == null ? void 0 : _a.debugLogs) {
+      console.log("[raindrop] using withTool in liveInteraction");
+    }
+    return traceloop.withTool(
+      {
+        name: toolName,
+        associationProperties: properties,
+        inputParameters: inputParams,
+        version: params.version,
+        traceContent: params.traceContent,
+        suppressTracing: params.suppressTracing
+      },
+      fn,
+      thisArg,
+      ...args
+    );
+  }
+  startSpan(params) {
+    const { name, properties = {} } = params;
+    const span = this.tracer.startSpan(name);
+    span.setAttributes(getPropertiesFromContext(this.context));
+    span.setAttribute("traceloop.span.kind", "task");
+    Object.entries(properties).forEach(([key, value]) => {
+      span.setAttribute("traceloop.association.properties." + key, String(value));
+    });
+    return span;
+  }
+  setProperties(properties) {
+    var _a;
+    this.context.properties = { ...this.context.properties, ...properties };
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      properties
+    });
+  }
+  setProperty(key, value) {
+    var _a;
+    this.context.properties = { ...this.context.properties, [key]: value };
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      properties: { [key]: value }
+    });
+  }
+  addAttachments(attachments) {
+    var _a;
+    if (!this.context.attachments) {
+      this.context.attachments = [];
+    }
+    this.context.attachments.push(...attachments);
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      attachments
+    });
+  }
+  setInput(input) {
+    var _a;
+    this.context.input = input;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      input
+    });
+  }
+  finish(resultEvent) {
+    var _a;
+    if (this.traceId) {
+      this.setProperty("trace_id", this.traceId);
+    }
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      ...resultEvent,
+      eventId: resultEvent.eventId || this.context.eventId,
+      isPending: false
+    });
+  }
+};
+
+// src/tracing/liveTracer.ts
+import * as traceloop2 from "@traceloop/node-server-sdk";
+var LiveTracer = class {
+  constructor(globalProperties) {
+    this.globalProperties = globalProperties || {};
+  }
+  async withSpan(params, fn, thisArg, ...args) {
+    const taskName = typeof params === "string" ? params : params.name;
+    const properties = typeof params === "string" ? {
+      ...this.globalProperties
+    } : {
+      ...this.globalProperties,
+      ...params.properties || {}
+    };
+    const inputParameters = typeof params === "string" ? void 0 : params.inputParameters;
+    return traceloop2.withTask(
+      {
+        name: taskName,
+        associationProperties: properties,
+        inputParameters,
+        traceContent: params.traceContent,
+        suppressTracing: params.suppressTracing
+      },
+      fn,
+      thisArg,
+      ...args
+    );
+  }
+};
+
+// src/tracing/tracer-core.ts
+function createDefaultInstrumentations() {
+  return [
+    new OpenAIInstrumentation(),
+    new AnthropicInstrumentation(),
+    new CohereInstrumentation(),
+    new BedrockInstrumentation(),
+    new VertexAIInstrumentation(),
+    new AIPlatformInstrumentation(),
+    new PineconeInstrumentation(),
+    new TogetherInstrumentation(),
+    new ChromaDBInstrumentation(),
+    new QdrantInstrumentation()
+  ];
+}
+function createManualInstrumentations(instrumentModules) {
+  const instrumentations = [];
+  if (instrumentModules.openAI) {
+    const inst = new OpenAIInstrumentation();
+    inst.manuallyInstrument(instrumentModules.openAI);
+    instrumentations.push(inst);
+  }
+  if (instrumentModules.anthropic) {
+    const inst = new AnthropicInstrumentation();
+    inst.manuallyInstrument(instrumentModules.anthropic);
+    instrumentations.push(inst);
+  }
+  if (instrumentModules.cohere) {
+    const inst = new CohereInstrumentation();
+    inst.manuallyInstrument(instrumentModules.cohere);
+    instrumentations.push(inst);
+  }
+  if (instrumentModules.bedrock) {
+    const inst = new BedrockInstrumentation();
+    inst.manuallyInstrument(instrumentModules.bedrock);
+    instrumentations.push(inst);
+  }
+  if (instrumentModules.google_vertexai) {
+    const inst = new VertexAIInstrumentation();
+    inst.manuallyInstrument(instrumentModules.google_vertexai);
+    instrumentations.push(inst);
+  }
+  if (instrumentModules.google_aiplatform) {
+    const inst = new AIPlatformInstrumentation();
+    inst.manuallyInstrument(instrumentModules.google_aiplatform);
+    instrumentations.push(inst);
+  }
+  if (instrumentModules.pinecone) {
+    const inst = new PineconeInstrumentation();
+    inst.manuallyInstrument(instrumentModules.pinecone);
+    instrumentations.push(inst);
+  }
+  if (instrumentModules.together) {
+    const inst = new TogetherInstrumentation();
+    inst.manuallyInstrument(instrumentModules.together);
+    instrumentations.push(inst);
+  }
+  if (instrumentModules.chromadb) {
+    const inst = new ChromaDBInstrumentation();
+    inst.manuallyInstrument(instrumentModules.chromadb);
+    instrumentations.push(inst);
+  }
+  if (instrumentModules.qdrant) {
+    const inst = new QdrantInstrumentation();
+    inst.manuallyInstrument(instrumentModules.qdrant);
+    instrumentations.push(inst);
+  }
+  return instrumentations;
+}
+var activeInteractions = new WeakValueMap();
+var activeInteractionsByEventId = new WeakValueMap();
+function getCurrentTraceId() {
+  var _a;
+  return (_a = trace2.getSpan(context.active())) == null ? void 0 : _a.spanContext().traceId;
+}
+var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
+  const { logLevel, useExternalOtel, tracingEnabled, ...otherOptions } = options;
+  if (isDebug) {
+    const mode = useExternalOtel ? "(external OTEL mode)" : tracingEnabled === false ? "(tracing disabled)" : "";
+    console.log("[raindrop] Initializing tracing", mode);
+  }
+  let traceloopInitialized = false;
+  try {
+    if (useExternalOtel) {
+      traceloop3.initialize({
+        baseUrl: apiUrl,
+        apiKey: writeKey,
+        logLevel,
+        tracingEnabled: false
+        // DO NOT create NodeSDK - customer has their own
+      });
+      traceloopInitialized = true;
+      if (isDebug) {
+        console.log(
+          "[raindrop] External OTEL mode active. Add raindrop.createSpanProcessor() to your NodeSDK's spanProcessors. Register instrumentations (AnthropicInstrumentation, etc.) on your NodeSDK."
+        );
+      }
+      if (otherOptions.instrumentModules && Object.keys(otherOptions.instrumentModules).length > 0) {
+        if (isDebug) {
+          console.log(
+            "[raindrop] instrumentModules configured. Call raindrop.getInstrumentations() to get instrumentation instances for your NodeSDK."
+          );
+        }
+      }
+    } else {
+      traceloop3.initialize({
+        baseUrl: apiUrl,
+        apiKey: writeKey,
+        ...otherOptions,
+        logLevel,
+        tracingEnabled: tracingEnabled !== false
+      });
+      traceloopInitialized = true;
+    }
+  } catch (error) {
+    console.warn(
+      "[raindrop] Failed to initialize traceloop. Spans will not be sent.",
+      error instanceof Error ? error.message : error
+    );
+  }
+  return {
+    /**
+     * Returns instrumentation instances for your NodeSDK.
+     * Add these to your NodeSDK when using useExternalOtel: true.
+     *
+     * - If `instrumentModules` is provided: returns only those specific instrumentations
+     * - If `instrumentModules` is NOT provided: returns ALL default instrumentations (auto-instrumentation)
+     *
+     * @example
+     * ```typescript
+     * const raindrop = new Raindrop({
+     *   useExternalOtel: true,
+     *   // instrumentModules is optional - if omitted, all instrumentations are returned
+     * });
+     *
+     * const sdk = new NodeSDK({
+     *   spanProcessors: [raindrop.createSpanProcessor()],
+     *   instrumentations: raindrop.getInstrumentations(),
+     * });
+     * sdk.start();
+     * ```
+     */
+    getInstrumentations() {
+      if (!useExternalOtel) {
+        console.warn(
+          "[raindrop] getInstrumentations() is meant for useExternalOtel: true. In default mode, instrumentations are automatically registered."
+        );
+      }
+      if (otherOptions.instrumentModules && Object.keys(otherOptions.instrumentModules).length > 0) {
+        return createManualInstrumentations(
+          otherOptions.instrumentModules
+        );
+      }
+      return createDefaultInstrumentations();
+    },
+    /**
+     * Creates a span processor to add to your NodeSDK.
+     * This sends spans to Raindrop.
+     *
+     * @example
+     * ```typescript
+     * const sdk = new NodeSDK({
+     *   spanProcessors: [raindrop.createSpanProcessor(), yourOtherProcessor],
+     *   instrumentations: raindrop.getInstrumentations(),
+     * });
+     * ```
+     */
+    createSpanProcessor(processorOptions) {
+      if (!useExternalOtel) {
+        console.warn(
+          "[raindrop] createSpanProcessor() is meant for useExternalOtel: true. In default mode, spans are automatically sent to Raindrop."
+        );
+      }
+      if (!traceloopInitialized) {
+        console.error("[raindrop] Cannot create span processor - traceloop failed to initialize.");
+        return {
+          forceFlush: async () => {
+          },
+          onStart: () => {
+          },
+          onEnd: () => {
+          },
+          shutdown: async () => {
+          }
+        };
+      }
+      return traceloop3.createSpanProcessor({
+        baseUrl: apiUrl,
+        apiKey: writeKey,
+        ...processorOptions != null ? processorOptions : {}
+      });
+    },
+    begin(traceContext) {
+      if (!traceContext.eventId) {
+        traceContext.eventId = crypto.randomUUID();
+      }
+      const traceId = getCurrentTraceId();
+      analytics._trackAiPartial({
+        ...traceContext
+      });
+      const interaction = new LiveInteraction(
+        traceContext,
+        traceId,
+        analytics
+      );
+      if (traceId) {
+        activeInteractions.set(traceId, interaction);
+      }
+      activeInteractionsByEventId.set(traceContext.eventId, interaction);
+      return interaction;
+    },
+    getActiveInteraction(eventId) {
+      const interactionByEventId = activeInteractionsByEventId.get(eventId);
+      if (interactionByEventId) {
+        return interactionByEventId;
+      }
+      const traceId = getCurrentTraceId();
+      if (traceId) {
+        const interactionByTraceId = activeInteractions.get(traceId);
+        if (interactionByTraceId) {
+          return interactionByTraceId;
+        }
+      }
+      const interaction = new LiveInteraction({ eventId }, traceId, analytics);
+      activeInteractionsByEventId.set(eventId, interaction);
+      return interaction;
+    },
+    tracer(globalProperties) {
+      return new LiveTracer(globalProperties);
+    },
+    async close() {
+      activeInteractions.clear();
+      activeInteractionsByEventId.clear();
+      if (traceloopInitialized) {
+        try {
+          await traceloop3.forceFlush();
+        } catch (e) {
+        }
+      }
+    }
+  };
+};
+
+export {
+  tracing
+};

package/dist/index.d.mts

@@ -1,3 +1,4 @@
+import * as _opentelemetry_instrumentation from '@opentelemetry/instrumentation';
 import { Span } from '@opentelemetry/api';
 import { z } from 'zod';
 import { SpanProcessorOptions } from '@traceloop/node-server-sdk';
@@ -398,10 +399,37 @@ interface AnalyticsConfig {
     endpoint?: string;
     redactPii?: boolean;
     /**
-     * false by default. If true, raindrop doesn't initialize OTEL tracing.
-     * you can then use the span processor using raindrop.createSpanProcessor()
+     * @deprecated Renamed to `useExternalOtel`. Use that instead.
+     * This option will be removed in a future version.
      */
     disableTracing?: boolean;
+    /**
+     * Set to true if you have your own OpenTelemetry setup (e.g., Sentry, Datadog).
+     *
+     * When true:
+     * - Raindrop won't create its own NodeSDK (avoids conflicts)
+     * - Use `raindrop.createSpanProcessor()` to get a processor for your NodeSDK
+     * - Use `raindrop.getInstrumentations()` to get configured LLM instrumentations
+     *
+     * @example
+     * ```ts
+     * import { NodeSDK } from "@opentelemetry/sdk-node";
+     * import Anthropic from "@anthropic-ai/sdk";
+     *
+     * const raindrop = new Raindrop({
+     *   writeKey: "xxx",
+     *   useExternalOtel: true,
+     *   instrumentModules: { anthropic: Anthropic },
+     * });
+     *
+     * const sdk = new NodeSDK({
+     *   spanProcessors: [raindrop.createSpanProcessor(), yourSentryProcessor],
+     *   instrumentations: raindrop.getInstrumentations(),
+     * });
+     * sdk.start();
+     * ```
+     */
+    useExternalOtel?: boolean;
     /**
      * false by default. If true, the SDK will not send any events or initialize tracing.
      * Useful for development/test environments.
@@ -479,6 +507,29 @@ declare class Raindrop {
      */
     tracer(globalProperties?: Record<string, string>): Tracer;
     createSpanProcessor(processorOptions?: SpanProcessorOptions): RaindropSpanProcessor;
+    /**
+     * Returns configured instrumentation instances based on instrumentModules.
+     * Add these to your NodeSDK when using useExternalOtel: true.
+     *
+     * @example
+     * ```ts
+     * import { NodeSDK } from "@opentelemetry/sdk-node";
+     * import Anthropic from "@anthropic-ai/sdk";
+     *
+     * const raindrop = new Raindrop({
+     *   writeKey: "xxx",
+     *   useExternalOtel: true,
+     *   instrumentModules: { anthropic: Anthropic },
+     * });
+     *
+     * const sdk = new NodeSDK({
+     *   spanProcessors: [raindrop.createSpanProcessor()],
+     *   instrumentations: raindrop.getInstrumentations(),
+     * });
+     * sdk.start();
+     * ```
+     */
+    getInstrumentations(): _opentelemetry_instrumentation.Instrumentation<_opentelemetry_instrumentation.InstrumentationConfig>[];
     /**
      * Resumes an existing interaction.
      *

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import * as _opentelemetry_instrumentation from '@opentelemetry/instrumentation';
 import { Span } from '@opentelemetry/api';
 import { z } from 'zod';
 import { SpanProcessorOptions } from '@traceloop/node-server-sdk';
@@ -398,10 +399,37 @@ interface AnalyticsConfig {
     endpoint?: string;
     redactPii?: boolean;
     /**
-     * false by default. If true, raindrop doesn't initialize OTEL tracing.
-     * you can then use the span processor using raindrop.createSpanProcessor()
+     * @deprecated Renamed to `useExternalOtel`. Use that instead.
+     * This option will be removed in a future version.
      */
     disableTracing?: boolean;
+    /**
+     * Set to true if you have your own OpenTelemetry setup (e.g., Sentry, Datadog).
+     *
+     * When true:
+     * - Raindrop won't create its own NodeSDK (avoids conflicts)
+     * - Use `raindrop.createSpanProcessor()` to get a processor for your NodeSDK
+     * - Use `raindrop.getInstrumentations()` to get configured LLM instrumentations
+     *
+     * @example
+     * ```ts
+     * import { NodeSDK } from "@opentelemetry/sdk-node";
+     * import Anthropic from "@anthropic-ai/sdk";
+     *
+     * const raindrop = new Raindrop({
+     *   writeKey: "xxx",
+     *   useExternalOtel: true,
+     *   instrumentModules: { anthropic: Anthropic },
+     * });
+     *
+     * const sdk = new NodeSDK({
+     *   spanProcessors: [raindrop.createSpanProcessor(), yourSentryProcessor],
+     *   instrumentations: raindrop.getInstrumentations(),
+     * });
+     * sdk.start();
+     * ```
+     */
+    useExternalOtel?: boolean;
     /**
      * false by default. If true, the SDK will not send any events or initialize tracing.
      * Useful for development/test environments.
@@ -479,6 +507,29 @@ declare class Raindrop {
      */
     tracer(globalProperties?: Record<string, string>): Tracer;
     createSpanProcessor(processorOptions?: SpanProcessorOptions): RaindropSpanProcessor;
+    /**
+     * Returns configured instrumentation instances based on instrumentModules.
+     * Add these to your NodeSDK when using useExternalOtel: true.
+     *
+     * @example
+     * ```ts
+     * import { NodeSDK } from "@opentelemetry/sdk-node";
+     * import Anthropic from "@anthropic-ai/sdk";
+     *
+     * const raindrop = new Raindrop({
+     *   writeKey: "xxx",
+     *   useExternalOtel: true,
+     *   instrumentModules: { anthropic: Anthropic },
+     * });
+     *
+     * const sdk = new NodeSDK({
+     *   spanProcessors: [raindrop.createSpanProcessor()],
+     *   instrumentations: raindrop.getInstrumentations(),
+     * });
+     * sdk.start();
+     * ```
+     */
+    getInstrumentations(): _opentelemetry_instrumentation.Instrumentation<_opentelemetry_instrumentation.InstrumentationConfig>[];
     /**
      * Resumes an existing interaction.
      *