@probelabs/probe 0.6.0-rc100

package/build/agent/appTracer.js

@@ -0,0 +1,360 @@
+import { trace, context, SpanStatusCode } from '@opentelemetry/api';
+
+/**
+ * Application-specific tracing layer for probe-agent
+ * Provides higher-level tracing functions for AI operations and tool calls
+ */
+export class AppTracer {
+  constructor(telemetryConfig, sessionId = null) {
+    this.telemetryConfig = telemetryConfig;
+    this.tracer = telemetryConfig?.getTracer();
+    this.sessionId = sessionId || this.generateSessionId();
+    this.traceId = this.generateTraceId();
+  }
+
+  /**
+   * Generate a unique session ID
+   */
+  generateSessionId() {
+    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+  }
+
+  /**
+   * Generate trace ID from session ID for consistent tracing
+   */
+  generateTraceId() {
+    if (!this.sessionId) return null;
+    
+    // Create a deterministic trace ID from session ID
+    const hash = this.hashString(this.sessionId);
+    return hash.padEnd(32, '0').substring(0, 32);
+  }
+
+  /**
+   * Simple hash function for session ID
+   */
+  hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash).toString(16);
+  }
+
+  /**
+   * Check if tracing is enabled
+   */
+  isEnabled() {
+    return this.tracer !== null;
+  }
+
+  /**
+   * Create a root span for the agent session
+   */
+  createSessionSpan(attributes = {}) {
+    if (!this.isEnabled()) return null;
+
+    return this.tracer.startSpan('agent.session', {
+      attributes: {
+        'session.id': this.sessionId,
+        'trace.id': this.traceId,
+        ...attributes,
+      },
+    });
+  }
+
+  /**
+   * Create a span for AI model requests
+   */
+  createAISpan(modelName, provider, attributes = {}) {
+    if (!this.isEnabled()) return null;
+
+    return this.tracer.startSpan('ai.request', {
+      attributes: {
+        'ai.model': modelName,
+        'ai.provider': provider,
+        'session.id': this.sessionId,
+        ...attributes,
+      },
+    });
+  }
+
+  /**
+   * Create a span for tool calls
+   */
+  createToolSpan(toolName, attributes = {}) {
+    if (!this.isEnabled()) return null;
+
+    return this.tracer.startSpan('tool.call', {
+      attributes: {
+        'tool.name': toolName,
+        'session.id': this.sessionId,
+        ...attributes,
+      },
+    });
+  }
+
+  /**
+   * Create a span for code search operations
+   */
+  createSearchSpan(query, attributes = {}) {
+    if (!this.isEnabled()) return null;
+
+    return this.tracer.startSpan('search.query', {
+      attributes: {
+        'search.query': query,
+        'session.id': this.sessionId,
+        ...attributes,
+      },
+    });
+  }
+
+  /**
+   * Create a span for code extraction operations
+   */
+  createExtractSpan(files, attributes = {}) {
+    if (!this.isEnabled()) return null;
+
+    return this.tracer.startSpan('extract.files', {
+      attributes: {
+        'extract.file_count': Array.isArray(files) ? files.length : 1,
+        'extract.files': Array.isArray(files) ? files.join(',') : files,
+        'session.id': this.sessionId,
+        ...attributes,
+      },
+    });
+  }
+
+  /**
+   * Create a span for agent iterations
+   */
+  createIterationSpan(iteration, attributes = {}) {
+    if (!this.isEnabled()) return null;
+
+    return this.tracer.startSpan('agent.iteration', {
+      attributes: {
+        'iteration.number': iteration,
+        'session.id': this.sessionId,
+        ...attributes,
+      },
+    });
+  }
+
+  /**
+   * Create a span for delegation operations
+   */
+  createDelegationSpan(task, attributes = {}) {
+    if (!this.isEnabled()) return null;
+
+    return this.tracer.startSpan('agent.delegation', {
+      attributes: {
+        'delegation.task': task.substring(0, 200) + (task.length > 200 ? '...' : ''),
+        'delegation.task_length': task.length,
+        'session.id': this.sessionId,
+        ...attributes,
+      },
+    });
+  }
+
+  /**
+   * Create a span for JSON validation operations
+   */
+  createJsonValidationSpan(responseLength, attributes = {}) {
+    if (!this.isEnabled()) return null;
+
+    return this.tracer.startSpan('validation.json', {
+      attributes: {
+        'validation.response_length': responseLength,
+        'session.id': this.sessionId,
+        ...attributes,
+      },
+    });
+  }
+
+  /**
+   * Create a span for Mermaid validation operations
+   */
+  createMermaidValidationSpan(diagramCount, attributes = {}) {
+    if (!this.isEnabled()) return null;
+
+    return this.tracer.startSpan('validation.mermaid', {
+      attributes: {
+        'validation.diagram_count': diagramCount,
+        'session.id': this.sessionId,
+        ...attributes,
+      },
+    });
+  }
+
+  /**
+   * Create a span for schema processing operations
+   */
+  createSchemaProcessingSpan(schemaType, attributes = {}) {
+    if (!this.isEnabled()) return null;
+
+    return this.tracer.startSpan('schema.processing', {
+      attributes: {
+        'schema.type': schemaType,
+        'session.id': this.sessionId,
+        ...attributes,
+      },
+    });
+  }
+
+  /**
+   * Record delegation events
+   */
+  recordDelegationEvent(eventType, data = {}) {
+    if (!this.isEnabled()) return;
+
+    this.addEvent(`delegation.${eventType}`, {
+      'session.id': this.sessionId,
+      ...data
+    });
+  }
+
+  /**
+   * Record JSON validation events
+   */
+  recordJsonValidationEvent(eventType, data = {}) {
+    if (!this.isEnabled()) return;
+
+    this.addEvent(`json_validation.${eventType}`, {
+      'session.id': this.sessionId,
+      ...data
+    });
+  }
+
+  /**
+   * Record Mermaid validation events
+   */
+  recordMermaidValidationEvent(eventType, data = {}) {
+    if (!this.isEnabled()) return;
+
+    this.addEvent(`mermaid_validation.${eventType}`, {
+      'session.id': this.sessionId,
+      ...data
+    });
+  }
+
+  /**
+   * Add an event to the current or most recent span
+   */
+  addEvent(name, attributes = {}) {
+    if (!this.isEnabled()) return;
+
+    // Try to add to the current span in context
+    const activeSpan = trace.getActiveSpan();
+    if (activeSpan) {
+      activeSpan.addEvent(name, {
+        'session.id': this.sessionId,
+        ...attributes,
+      });
+    } else {
+      // Fallback: log as structured data if no active span
+      if (this.telemetryConfig?.enableConsole) {
+        console.log(`[Event] ${name}:`, attributes);
+      }
+    }
+  }
+
+  /**
+   * Set attributes on the current span
+   */
+  setAttributes(attributes) {
+    if (!this.isEnabled()) return;
+
+    const activeSpan = trace.getActiveSpan();
+    if (activeSpan) {
+      activeSpan.setAttributes({
+        'session.id': this.sessionId,
+        ...attributes,
+      });
+    }
+  }
+
+  /**
+   * Wrap a function with automatic span creation
+   */
+  wrapFunction(spanName, fn, attributes = {}) {
+    if (!this.isEnabled()) {
+      return fn;
+    }
+
+    return async (...args) => {
+      const span = this.tracer.startSpan(spanName, {
+        attributes: {
+          'session.id': this.sessionId,
+          ...attributes,
+        },
+      });
+
+      try {
+        const result = await context.with(trace.setSpan(context.active(), span), () => fn(...args));
+        span.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (error) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: error.message,
+        });
+        span.recordException(error);
+        throw error;
+      } finally {
+        span.end();
+      }
+    };
+  }
+
+  /**
+   * Execute a function within a span context
+   */
+  async withSpan(spanName, fn, attributes = {}) {
+    if (!this.isEnabled()) {
+      return fn();
+    }
+
+    const span = this.tracer.startSpan(spanName, {
+      attributes: {
+        'session.id': this.sessionId,
+        ...attributes,
+      },
+    });
+
+    try {
+      const result = await context.with(trace.setSpan(context.active(), span), () => fn());
+      span.setStatus({ code: SpanStatusCode.OK });
+      return result;
+    } catch (error) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error.message,
+      });
+      span.recordException(error);
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+
+
+  /**
+   * Force flush all pending spans
+   */
+  async flush() {
+    if (this.telemetryConfig) {
+      await this.telemetryConfig.forceFlush();
+    }
+  }
+
+  /**
+   * Shutdown tracing
+   */
+  async shutdown() {
+    if (this.telemetryConfig) {
+      await this.telemetryConfig.shutdown();
+    }
+  }
+}

package/build/agent/fileSpanExporter.js

@@ -0,0 +1,169 @@
+import { createWriteStream } from 'fs';
+import corePkg from '@opentelemetry/core';
+
+const { ExportResultCode } = corePkg;
+
+/**
+ * File exporter for OpenTelemetry spans
+ * Exports spans to a file in JSON Lines format (one JSON object per line)
+ * Following the OTLP JSON format specification
+ */
+export class FileSpanExporter {
+  constructor(filePath = './traces.jsonl') {
+    this.filePath = filePath;
+    this.stream = createWriteStream(filePath, { flags: 'a' });
+    this.stream.on('error', (error) => {
+      console.error(`[FileSpanExporter] Stream error: ${error.message}`);
+    });
+  }
+
+  /**
+   * Export spans to file
+   * @param {ReadableSpan[]} spans - Array of spans to export
+   * @param {function} resultCallback - Callback to call with the export result
+   */
+  export(spans, resultCallback) {
+    if (!spans || spans.length === 0) {
+      resultCallback({ code: ExportResultCode.SUCCESS });
+      return;
+    }
+
+    try {
+      const timestamp = Date.now();
+      
+      spans.forEach((span, index) => {
+        // Extract parent span ID - check various possible properties
+        let parentSpanId = undefined;
+        
+        if (span.parentSpanContext) {
+          parentSpanId = span.parentSpanContext.spanId;
+        } else if (span._parentSpanContext) {
+          parentSpanId = span._parentSpanContext.spanId;
+        } else if (span.parent) {
+          parentSpanId = span.parent.spanId;
+        } else if (span._parent) {
+          parentSpanId = span._parent.spanId;
+        } else if (span._parentId) {
+          parentSpanId = span._parentId;
+        } else if (span.parentSpanId) {
+          parentSpanId = span.parentSpanId;
+        }
+        
+        // Convert span to OTLP JSON format
+        const spanData = {
+          traceId: span.spanContext().traceId,
+          spanId: span.spanContext().spanId,
+          parentSpanId: parentSpanId,
+          name: span.name,
+          kind: span.kind,
+          startTimeUnixNano: span.startTime[0] * 1_000_000_000 + span.startTime[1],
+          endTimeUnixNano: span.endTime[0] * 1_000_000_000 + span.endTime[1],
+          attributes: this.convertAttributes(span.attributes),
+          status: span.status,
+          events: span.events?.map(event => ({
+            timeUnixNano: event.time[0] * 1_000_000_000 + event.time[1],
+            name: event.name,
+            attributes: this.convertAttributes(event.attributes),
+          })) || [],
+          links: span.links?.map(link => ({
+            traceId: link.context.traceId,
+            spanId: link.context.spanId,
+            attributes: this.convertAttributes(link.attributes),
+          })) || [],
+          resource: {
+            attributes: this.convertAttributes(span.resource?.attributes || {}),
+          },
+          instrumentationLibrary: {
+            name: span.instrumentationLibrary?.name || 'unknown',
+            version: span.instrumentationLibrary?.version || 'unknown',
+          },
+          timestamp,
+        };
+
+        // Write as JSON Lines format (one JSON object per line)
+        this.stream.write(JSON.stringify(spanData) + '\n');
+      });
+
+      resultCallback({ code: ExportResultCode.SUCCESS });
+    } catch (error) {
+      console.error(`[FileSpanExporter] Export error: ${error.message}`);
+      resultCallback({ 
+        code: ExportResultCode.FAILED, 
+        error: error 
+      });
+    }
+  }
+
+  /**
+   * Convert OpenTelemetry attributes to plain object
+   * @param {Object} attributes - OpenTelemetry attributes
+   * @returns {Object} Plain object with string values
+   */
+  convertAttributes(attributes) {
+    if (!attributes) return {};
+    
+    const result = {};
+    for (const [key, value] of Object.entries(attributes)) {
+      // Convert all values to strings for JSON compatibility
+      if (typeof value === 'object' && value !== null) {
+        result[key] = JSON.stringify(value);
+      } else {
+        result[key] = String(value);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Shutdown the exporter
+   * @returns {Promise<void>}
+   */
+  async shutdown() {
+    return new Promise((resolve) => {
+      if (this.stream) {
+        this.stream.end(() => {
+          console.log(`[FileSpanExporter] File stream closed: ${this.filePath}`);
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  /**
+   * Force flush any pending spans
+   * @returns {Promise<void>}
+   */
+  async forceFlush() {
+    return new Promise((resolve, reject) => {
+      if (this.stream) {
+        const flushTimeout = setTimeout(() => {
+          console.warn('[FileSpanExporter] Flush timeout after 5 seconds');
+          resolve();
+        }, 5000);
+        
+        // Uncork the stream to force buffered writes
+        if (this.stream.writableCorked) {
+          this.stream.uncork();
+        }
+        
+        // If there's buffered data, wait for drain event
+        if (this.stream.writableNeedDrain) {
+          this.stream.once('drain', () => {
+            clearTimeout(flushTimeout);
+            resolve();
+          });
+        } else {
+          // No buffered data, but still give it a moment to ensure writes complete
+          setImmediate(() => {
+            clearTimeout(flushTimeout);
+            resolve();
+          });
+        }
+      } else {
+        resolve();
+      }
+    });
+  }
+}