@probelabs/probe 0.6.0-rc147 → 0.6.0-rc149

package/cjs/agent/telemetry.cjs

@@ -1,358 +0,0 @@
-"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/agent/telemetry.js
-var telemetry_exports = {};
-__export(telemetry_exports, {
-  TelemetryConfig: () => TelemetryConfig,
-  initializeTelemetryFromOptions: () => initializeTelemetryFromOptions
-});
-module.exports = __toCommonJS(telemetry_exports);
-var import_sdk_node = require("@opentelemetry/sdk-node");
-var import_resources = require("@opentelemetry/resources");
-var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
-var import_api = require("@opentelemetry/api");
-var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
-var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
-var import_fs2 = require("fs");
-var import_path = require("path");
-
-// src/agent/fileSpanExporter.js
-var import_fs = require("fs");
-var import_core = require("@opentelemetry/core");
-var FileSpanExporter = class {
-  constructor(filePath = "./traces.jsonl") {
-    this.filePath = filePath;
-    this.stream = (0, import_fs.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: import_core.ExportResultCode.SUCCESS });
-      return;
-    }
-    try {
-      const timestamp = Date.now();
-      spans.forEach((span, index) => {
-        let parentSpanId = void 0;
-        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;
-        }
-        const spanData = {
-          traceId: span.spanContext().traceId,
-          spanId: span.spanContext().spanId,
-          parentSpanId,
-          name: span.name,
-          kind: span.kind,
-          startTimeUnixNano: span.startTime[0] * 1e9 + span.startTime[1],
-          endTimeUnixNano: span.endTime[0] * 1e9 + span.endTime[1],
-          attributes: this.convertAttributes(span.attributes),
-          status: span.status,
-          events: span.events?.map((event) => ({
-            timeUnixNano: event.time[0] * 1e9 + 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
-        };
-        this.stream.write(JSON.stringify(spanData) + "\n");
-      });
-      resultCallback({ code: import_core.ExportResultCode.SUCCESS });
-    } catch (error) {
-      console.error(`[FileSpanExporter] Export error: ${error.message}`);
-      resultCallback({
-        code: import_core.ExportResultCode.FAILED,
-        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)) {
-      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();
-        }, 5e3);
-        if (this.stream.writableCorked) {
-          this.stream.uncork();
-        }
-        if (this.stream.writableNeedDrain) {
-          this.stream.once("drain", () => {
-            clearTimeout(flushTimeout);
-            resolve();
-          });
-        } else {
-          setImmediate(() => {
-            clearTimeout(flushTimeout);
-            resolve();
-          });
-        }
-      } else {
-        resolve();
-      }
-    });
-  }
-};
-
-// src/agent/telemetry.js
-var TelemetryConfig = class {
-  constructor(options = {}) {
-    this.serviceName = options.serviceName || "probe-agent";
-    this.serviceVersion = options.serviceVersion || "1.0.0";
-    this.enableFile = options.enableFile || false;
-    this.enableRemote = options.enableRemote || false;
-    this.enableConsole = options.enableConsole || false;
-    this.filePath = options.filePath || "./traces.jsonl";
-    this.remoteEndpoint = options.remoteEndpoint || "http://localhost:4318/v1/traces";
-    this.sdk = null;
-    this.tracer = null;
-  }
-  /**
-   * Initialize OpenTelemetry SDK
-   */
-  initialize() {
-    if (this.sdk) {
-      console.warn("Telemetry already initialized");
-      return;
-    }
-    const resource = (0, import_resources.resourceFromAttributes)({
-      [import_semantic_conventions.ATTR_SERVICE_NAME]: this.serviceName,
-      [import_semantic_conventions.ATTR_SERVICE_VERSION]: this.serviceVersion
-    });
-    const spanProcessors = [];
-    if (this.enableFile) {
-      try {
-        const dir = (0, import_path.dirname)(this.filePath);
-        if (!(0, import_fs2.existsSync)(dir)) {
-          (0, import_fs2.mkdirSync)(dir, { recursive: true });
-        }
-        const fileExporter = new FileSpanExporter(this.filePath);
-        spanProcessors.push(new import_sdk_trace_base.BatchSpanProcessor(fileExporter, {
-          maxQueueSize: 2048,
-          maxExportBatchSize: 512,
-          scheduledDelayMillis: 500,
-          exportTimeoutMillis: 3e4
-        }));
-        console.log(`[Telemetry] File exporter enabled, writing to: ${this.filePath}`);
-      } catch (error) {
-        console.error(`[Telemetry] Failed to initialize file exporter: ${error.message}`);
-      }
-    }
-    if (this.enableRemote) {
-      try {
-        const remoteExporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({
-          url: this.remoteEndpoint
-        });
-        spanProcessors.push(new import_sdk_trace_base.BatchSpanProcessor(remoteExporter, {
-          maxQueueSize: 2048,
-          maxExportBatchSize: 512,
-          scheduledDelayMillis: 500,
-          exportTimeoutMillis: 3e4
-        }));
-        console.log(`[Telemetry] Remote exporter enabled, endpoint: ${this.remoteEndpoint}`);
-      } catch (error) {
-        console.error(`[Telemetry] Failed to initialize remote exporter: ${error.message}`);
-      }
-    }
-    if (this.enableConsole) {
-      const consoleExporter = new import_sdk_trace_base.ConsoleSpanExporter();
-      spanProcessors.push(new import_sdk_trace_base.BatchSpanProcessor(consoleExporter, {
-        maxQueueSize: 2048,
-        maxExportBatchSize: 512,
-        scheduledDelayMillis: 500,
-        exportTimeoutMillis: 3e4
-      }));
-      console.log(`[Telemetry] Console exporter enabled`);
-    }
-    if (spanProcessors.length === 0) {
-      console.log("[Telemetry] No exporters configured, telemetry will not be collected");
-      return;
-    }
-    this.sdk = new import_sdk_node.NodeSDK({
-      resource,
-      spanProcessors
-    });
-    try {
-      this.sdk.start();
-      this.tracer = import_api.trace.getTracer(this.serviceName, this.serviceVersion);
-      console.log(`[Telemetry] OpenTelemetry SDK initialized successfully`);
-    } catch (error) {
-      console.error(`[Telemetry] Failed to start OpenTelemetry SDK: ${error.message}`);
-    }
-  }
-  /**
-   * Get the tracer instance
-   */
-  getTracer() {
-    return this.tracer;
-  }
-  /**
-   * Create a span with the given name and attributes
-   */
-  createSpan(name, attributes = {}) {
-    if (!this.tracer) {
-      return null;
-    }
-    return this.tracer.startSpan(name, {
-      attributes
-    });
-  }
-  /**
-   * Wrap a function to automatically create spans
-   */
-  wrapFunction(name, fn, attributes = {}) {
-    if (!this.tracer) {
-      return fn;
-    }
-    return async (...args) => {
-      const span = this.createSpan(name, attributes);
-      if (!span) {
-        return fn(...args);
-      }
-      try {
-        const result = await import_api.context.with(import_api.trace.setSpan(import_api.context.active(), span), () => fn(...args));
-        span.setStatus({ code: import_api.SpanStatusCode.OK });
-        return result;
-      } catch (error) {
-        span.setStatus({
-          code: import_api.SpanStatusCode.ERROR,
-          message: error.message
-        });
-        span.recordException(error);
-        throw error;
-      } finally {
-        span.end();
-      }
-    };
-  }
-  /**
-   * Force flush all pending spans
-   */
-  async forceFlush() {
-    if (this.sdk) {
-      try {
-        const tracerProvider = import_api.trace.getTracerProvider();
-        if (tracerProvider && typeof tracerProvider.forceFlush === "function") {
-          await tracerProvider.forceFlush();
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        console.log("[Telemetry] OpenTelemetry spans flushed successfully");
-      } catch (error) {
-        console.error(`[Telemetry] Failed to flush OpenTelemetry spans: ${error.message}`);
-      }
-    }
-  }
-  /**
-   * Shutdown telemetry
-   */
-  async shutdown() {
-    if (this.sdk) {
-      try {
-        await this.sdk.shutdown();
-        console.log("[Telemetry] OpenTelemetry SDK shutdown successfully");
-      } catch (error) {
-        console.error(`[Telemetry] Failed to shutdown OpenTelemetry SDK: ${error.message}`);
-      }
-    }
-  }
-};
-function initializeTelemetryFromOptions(options) {
-  const config = new TelemetryConfig({
-    serviceName: "probe-agent",
-    serviceVersion: "1.0.0",
-    enableFile: options.traceFile !== void 0,
-    enableRemote: options.traceRemote !== void 0,
-    enableConsole: options.traceConsole,
-    filePath: options.traceFile || "./traces.jsonl",
-    remoteEndpoint: options.traceRemote || "http://localhost:4318/v1/traces"
-  });
-  config.initialize();
-  return config;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TelemetryConfig,
-  initializeTelemetryFromOptions
-});

package/src/agent/appTracer.js

@@ -1,360 +0,0 @@
-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();
-    }
-  }
-}