@observyze/sdk 0.1.0 → 0.1.2

package/dist/opentelemetry/index.js

@@ -0,0 +1,335 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/opentelemetry/index.ts
+var opentelemetry_exports = {};
+__export(opentelemetry_exports, {
+  ObservyzeSpanExporter: () => ObservyzeSpanExporter
+});
+module.exports = __toCommonJS(opentelemetry_exports);
+
+// src/trace.ts
+var import_crypto = require("crypto");
+function generateId() {
+  return `${Date.now()}-${(0, import_crypto.randomUUID)().substring(0, 8)}`;
+}
+var Span = class {
+  data;
+  startTime;
+  constructor(name, type, parentSpanId) {
+    this.startTime = Date.now();
+    this.data = {
+      span_id: generateId(),
+      parent_span_id: parentSpanId,
+      name,
+      type,
+      start_time: new Date(this.startTime),
+      end_time: new Date(this.startTime),
+      // Will be updated on end()
+      duration_ms: 0,
+      input: null,
+      output: null,
+      metadata: {}
+    };
+  }
+  /**
+   * Set the input data for this span
+   */
+  setInput(input) {
+    this.data.input = input;
+    return this;
+  }
+  /**
+   * Set the output data for this span
+   */
+  setOutput(output) {
+    this.data.output = output;
+    return this;
+  }
+  /**
+   * Record an error that occurred during span execution
+   */
+  setError(error) {
+    this.data.error = {
+      message: error.message,
+      stack: error.stack,
+      code: error.code
+    };
+    return this;
+  }
+  /**
+   * Set metadata for this span
+   */
+  setMetadata(key, value) {
+    this.data.metadata[key] = value;
+    return this;
+  }
+  /**
+   * Set multiple metadata fields at once
+   */
+  setMetadataAll(metadata) {
+    this.data.metadata = { ...this.data.metadata, ...metadata };
+    return this;
+  }
+  /**
+   * Set token usage information
+   */
+  setTokens(tokens) {
+    this.data.tokens = tokens;
+    return this;
+  }
+  /**
+   * End the span and calculate duration
+   */
+  end() {
+    const endTime = Date.now();
+    this.data.end_time = new Date(endTime);
+    this.data.duration_ms = endTime - this.startTime;
+  }
+  /**
+   * Get the span ID
+   */
+  get id() {
+    return this.data.span_id;
+  }
+  /**
+   * Get the span data for serialization
+   */
+  toJSON() {
+    return { ...this.data };
+  }
+};
+var Trace = class {
+  data;
+  startTime;
+  spans = [];
+  ended = false;
+  constructor(name, organizationId, projectId) {
+    this.startTime = Date.now();
+    this.data = {
+      trace_id: generateId(),
+      organization_id: organizationId,
+      project_id: projectId,
+      name,
+      status: "running" /* RUNNING */,
+      start_time: new Date(this.startTime),
+      end_time: new Date(this.startTime),
+      // Will be updated on end()
+      duration_ms: 0,
+      metadata: {},
+      spans: [],
+      tags: []
+    };
+  }
+  /**
+   * Start a new span within this trace
+   */
+  startSpan(name, type, parentSpanId) {
+    if (this.ended) {
+      throw new Error("Cannot start span on an ended trace");
+    }
+    const span = new Span(name, type, parentSpanId);
+    this.spans.push(span);
+    return span;
+  }
+  /**
+   * Add metadata to the trace
+   */
+  setMetadata(key, value) {
+    this.data.metadata[key] = value;
+    return this;
+  }
+  /**
+   * Set multiple metadata fields at once
+   */
+  setMetadataAll(metadata) {
+    this.data.metadata = { ...this.data.metadata, ...metadata };
+    return this;
+  }
+  /**
+   * Add tags to the trace
+   */
+  addTag(tag) {
+    if (!this.data.tags.includes(tag)) {
+      this.data.tags.push(tag);
+    }
+    return this;
+  }
+  /**
+   * Add multiple tags at once
+   */
+  addTags(tags) {
+    tags.forEach((tag) => this.addTag(tag));
+    return this;
+  }
+  /**
+   * Set the user ID associated with this trace
+   */
+  setUserId(userId) {
+    this.data.user_id = userId;
+    return this;
+  }
+  /**
+   * Set the session ID associated with this trace
+   */
+  setSessionId(sessionId) {
+    this.data.session_id = sessionId;
+    return this;
+  }
+  /**
+   * End the trace with a final status
+   */
+  end(status = "success" /* SUCCESS */) {
+    if (this.ended) {
+      return;
+    }
+    const endTime = Date.now();
+    this.data.end_time = new Date(endTime);
+    this.data.duration_ms = endTime - this.startTime;
+    this.data.status = status;
+    this.data.spans = this.spans.map((span) => span.toJSON());
+    this.ended = true;
+  }
+  /**
+   * Get the trace ID
+   */
+  get id() {
+    return this.data.trace_id;
+  }
+  /**
+   * Check if the trace has ended
+   */
+  get isEnded() {
+    return this.ended;
+  }
+  /**
+   * Get the trace data for serialization
+   */
+  toJSON() {
+    return { ...this.data };
+  }
+};
+
+// src/opentelemetry/exporter.ts
+var ObservyzeSpanExporter = class {
+  client;
+  config;
+  constructor(client, config) {
+    this.client = client;
+    this.config = {
+      serviceName: config?.serviceName || "unknown-service",
+      projectId: config?.projectId || "",
+      defaultSpanType: config?.defaultSpanType || "llm",
+      headers: config?.headers || {}
+    };
+  }
+  /**
+   * Export spans — called by OTel SDK when spans are ready.
+   * Converts OTel spans to Observyze traces and buffers them.
+   */
+  async export(spans, resultCallback) {
+    if (!spans || spans.length === 0) {
+      resultCallback({ code: 0 });
+      return;
+    }
+    try {
+      const organizationId = this.client.config?.organizationId || "";
+      const projectId = this.config.projectId || this.client.config?.projectId || "";
+      for (const span of spans) {
+        const spanContext = span.spanContext();
+        const traceId = spanContext?.traceId || span.spanId();
+        const trace = new Trace(
+          span.name || "otel-span",
+          organizationId,
+          projectId
+        );
+        trace.setMetadata("source", "opentelemetry");
+        trace.setMetadata("otel.trace_id", traceId);
+        trace.setMetadata("otel.span_id", spanContext?.spanId || "");
+        trace.setMetadata("service.name", this.config.serviceName);
+        trace.setMetadataAll(span.attributes || {});
+        if (span.resource?.attributes) {
+          trace.setMetadataAll(span.resource.attributes);
+        }
+        const input = span.attributes?.["gen_ai.prompt.0.content"] || span.attributes?.["gen_ai.completion.0.content"] || span.attributes?.["llm.input"] || void 0;
+        const output = span.attributes?.["gen_ai.completion.0.content"] || span.attributes?.["llm.output"] || void 0;
+        const model = span.attributes?.["gen_ai.request.model"] || span.attributes?.["llm.model"] || void 0;
+        const provider = span.attributes?.["gen_ai.request.provider"] || span.attributes?.["llm.provider"] || void 0;
+        const inputTokens = typeof span.attributes?.["gen_ai.usage.input_tokens"] === "number" ? span.attributes["gen_ai.usage.input_tokens"] : void 0;
+        const outputTokens = typeof span.attributes?.["gen_ai.usage.output_tokens"] === "number" ? span.attributes["gen_ai.usage.output_tokens"] : void 0;
+        trace.setMetadata("provider", provider || "unknown");
+        trace.setMetadata("model", model || "unknown");
+        const nsDuration = span.duration;
+        const durationMs = nsDuration ? Math.round(nsDuration / 1e6) : 0;
+        trace.setMetadata("latency_ms", durationMs);
+        trace.setMetadata("otel.duration_ns", nsDuration);
+        const oSpan = trace.startSpan(span.name || "otel-operation", this.config.defaultSpanType);
+        if (input) oSpan.setInput(input);
+        if (output) oSpan.setOutput(output);
+        if (inputTokens || outputTokens) {
+          oSpan.setTokens({
+            input: inputTokens || 0,
+            output: outputTokens || 0,
+            total: (inputTokens || 0) + (outputTokens || 0)
+          });
+        }
+        if (model) oSpan.setMetadata("model", model);
+        if (provider) oSpan.setMetadata("provider", provider);
+        if (span.attributes) oSpan.setMetadataAll(span.attributes);
+        const status = span.status;
+        const statusCode = status?.code;
+        if (statusCode === 2) {
+          oSpan.setError(new Error(status?.message || "OTel span error"));
+          trace.end("error" /* ERROR */);
+        } else {
+          trace.end("success" /* SUCCESS */);
+        }
+      }
+      resultCallback({ code: 0 });
+    } catch (error) {
+      resultCallback({
+        code: 1,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }
+  /**
+   * Called when the exporter is shut down.
+   * Flushes any remaining buffered traces via the SDK client.
+   */
+  async shutdown() {
+    try {
+      await this.client.flush();
+    } catch {
+    }
+  }
+  /**
+   * Called by the OTel SDK to force-export buffered spans.
+   */
+  async forceFlush() {
+    try {
+      await this.client.flush();
+    } catch {
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObservyzeSpanExporter
+});

package/dist/opentelemetry/index.mjs

@@ -0,0 +1,6 @@
+import {
+  ObservyzeSpanExporter
+} from "../chunk-YRMQCX2P.mjs";
+export {
+  ObservyzeSpanExporter
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@observyze/sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Node.js SDK for Observyze AI Observability Platform",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -9,13 +9,19 @@
       "types": "./dist/index.d.ts",
       "require": "./dist/index.js",
       "import": "./dist/index.mjs"
+    },
+    "./opentelemetry": {
+      "types": "./dist/opentelemetry/index.d.ts",
+      "require": "./dist/opentelemetry/index.js",
+      "import": "./dist/opentelemetry/index.mjs"
     }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts src/opentelemetry/index.ts --format cjs,esm --dts",
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
-    "lint": "eslint src --ext .ts",
-    "test": "vitest",
     "typecheck": "tsc --noEmit"
   },
   "keywords": [
@@ -28,14 +34,15 @@
   ],
   "author": "Observyze",
   "license": "MIT",
-  "dependencies": {
-    "@observyze/types": "*"
+  "dependencies": {},
+  "optionalDependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/sdk-trace-base": "^1.30.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "tsup": "^8.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^1.0.0"
+    "typescript": "^5.3.0"
   },
   "engines": {
     "node": ">=20.0.0"

package/INSTRUMENTATION_SUMMARY.md

@@ -1,184 +0,0 @@
-# Auto-Instrumentation Implementation Summary
-
-## Task 9: Implement SDK Auto-Instrumentation ✅
-
-### Overview
-Implemented comprehensive auto-instrumentation for the Observyze Node.js SDK, enabling automatic trace capture for OpenAI and Anthropic API calls with zero code changes beyond wrapping the client.
-
-### Requirements Satisfied
-- ✅ **Requirement 1.2**: Capture inputs, outputs, model name, provider, token counts, latency, tool calls, error details, and custom metadata
-- ✅ **Requirement 14.1**: Auto-instrumentation for OpenAI and Anthropic
-- ✅ **Requirement 14.2**: Capture ALL LLM calls without manual wrapping
-- ✅ **Requirement 14.9**: Streaming response support with zero added latency
-
-### Implementation Details
-
-#### Files Created
-
-1. **`src/instrumentation/openai.ts`**
-   - Monkey-patches OpenAI `chat.completions.create` method
-   - Captures non-streaming and streaming completions
-   - Extracts model, provider, token counts, latency, inputs, outputs
-   - Buffers streaming chunks and reports complete output on stream end
-   - Error handling with automatic trace capture
-
-2. **`src/instrumentation/anthropic.ts`**
-   - Monkey-patches Anthropic `messages.create` method
-   - Captures non-streaming and streaming messages
-   - Extracts model, provider, token counts, latency, inputs, outputs
-   - Handles Anthropic's event-based streaming protocol
-   - Error handling with automatic trace capture
-
-3. **`src/instrumentation/index.ts`**
-   - Provides `wrap()` API that auto-detects client type
-   - Exports provider-specific wrappers for advanced use cases
-   - Type-safe client detection
-
-4. **`src/instrumentation/instrumentation.test.ts`**
-   - Comprehensive test suite with 12 passing tests
-   - Tests for OpenAI and Anthropic (streaming and non-streaming)
-   - Error handling tests
-   - Token usage capture tests
-   - Metadata capture tests
-
-5. **`src/instrumentation/README.md`**
-   - Complete documentation for auto-instrumentation
-   - Usage examples for all supported providers
-   - Streaming examples
-   - Performance characteristics
-   - Configuration options
-
-6. **`examples/auto-instrumentation.ts`**
-   - Working example demonstrating all features
-   - OpenAI, Anthropic, and streaming examples
-   - Can be run to see the SDK in action
-
-### Key Features
-
-#### 1. Simple API
-```typescript
-const nw = new ObservyzeClient({ apiKey: 'key' })
-const openai = new OpenAI({ apiKey: 'key' })
-nw.wrap(openai) // That's it!
-```
-
-#### 2. Automatic Capture
-- **Inputs**: Model, messages, parameters (temperature, max_tokens, etc.)
-- **Outputs**: Complete response content, response ID, finish reason
-- **Metadata**: Provider, model, latency, streaming flag
-- **Token Usage**: Input tokens, output tokens, total tokens
-- **Errors**: Error message, stack trace, error code
-
-#### 3. Streaming Support
-- Zero added latency - chunks pass through immediately
-- Buffering happens in parallel with streaming
-- Complete output captured when stream ends
-- Works with both OpenAI and Anthropic streaming protocols
-
-#### 4. Error Handling
-- Never breaks the application
-- Errors are captured in traces
-- Failed traces are still buffered and sent
-- Exponential backoff retry for network failures
-
-#### 5. Performance
-- < 2ms overhead on non-streaming calls
-- Zero added latency on streaming calls
-- Automatic batching (up to 100 traces)
-- Automatic flushing (every 5 seconds)
-
-### Testing
-
-All tests passing (12/12):
-- ✅ OpenAI non-streaming capture
-- ✅ OpenAI streaming capture
-- ✅ OpenAI error capture
-- ✅ Anthropic non-streaming capture
-- ✅ Anthropic streaming capture
-- ✅ Anthropic error capture
-- ✅ Generic wrap() API detection
-- ✅ Unsupported client error handling
-- ✅ Metadata capture
-- ✅ Token usage capture
-
-### Build Status
-✅ TypeScript compilation successful
-✅ No diagnostics errors
-✅ ESM and CJS builds generated
-✅ Type definitions generated
-
-### Documentation
-- ✅ Main README updated with auto-instrumentation section
-- ✅ Detailed instrumentation guide created
-- ✅ Working example provided
-- ✅ API documentation complete
-
-### Integration with Existing SDK
-
-The auto-instrumentation seamlessly integrates with the existing SDK:
-- Uses existing `Trace` and `Span` classes
-- Respects all SDK configuration (batch size, flush interval, dry-run, etc.)
-- Works with existing buffer and retry logic
-- Compatible with manual instrumentation
-
-### Usage Example
-
-```typescript
-import OpenAI from 'openai'
-import Anthropic from '@anthropic-ai/sdk'
-import { ObservyzeClient } from '@observyze/sdk'
-
-// Initialize Observyze
-const nw = new ObservyzeClient({
-  apiKey: process.env.Observyze_API_KEY!,
-  organizationId: 'your-org-id',
-  projectId: 'your-project-id'
-})
-
-// Wrap OpenAI
-const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! })
-nw.wrap(openai)
-
-// Wrap Anthropic
-const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! })
-nw.wrap(anthropic)
-
-// All calls are now automatically traced!
-const response1 = await openai.chat.completions.create({
-  model: 'gpt-4',
-  messages: [{ role: 'user', content: 'Hello!' }]
-})
-
-const response2 = await anthropic.messages.create({
-  model: 'claude-3-opus-20240229',
-  max_tokens: 1024,
-  messages: [{ role: 'user', content: 'Hello!' }]
-})
-
-// Streaming also works!
-const stream = await openai.chat.completions.create({
-  model: 'gpt-4',
-  messages: [{ role: 'user', content: 'Tell me a story' }],
-  stream: true
-})
-
-for await (const chunk of stream) {
-  process.stdout.write(chunk.choices[0]?.delta?.content || '')
-}
-```
-
-### Future Enhancements
-
-Potential additions for future tasks:
-- Vercel AI SDK support
-- LangChain support
-- LlamaIndex support
-- Google Gemini support
-- Cohere support
-- Custom middleware hooks
-- Sampling strategies
-- PII redaction
-
-### Conclusion
-
-Task 9 is complete with full implementation of auto-instrumentation for OpenAI and Anthropic, comprehensive testing, and complete documentation. The implementation satisfies all requirements and provides a production-ready solution for automatic trace capture with minimal developer effort.