@probelabs/probe 0.6.0-rc135 → 0.6.0-rc137

package/cjs/agent/simpleTelemetry.cjs

@@ -0,0 +1,250 @@
+"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/simpleTelemetry.js
+var simpleTelemetry_exports = {};
+__export(simpleTelemetry_exports, {
+  SimpleAppTracer: () => SimpleAppTracer,
+  SimpleTelemetry: () => SimpleTelemetry,
+  initializeSimpleTelemetryFromOptions: () => initializeSimpleTelemetryFromOptions
+});
+module.exports = __toCommonJS(simpleTelemetry_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var SimpleTelemetry = class {
+  constructor(options = {}) {
+    this.serviceName = options.serviceName || "probe-agent";
+    this.enableFile = options.enableFile || false;
+    this.enableConsole = options.enableConsole || false;
+    this.filePath = options.filePath || "./traces.jsonl";
+    this.stream = null;
+    if (this.enableFile) {
+      this.initializeFileExporter();
+    }
+  }
+  initializeFileExporter() {
+    try {
+      const dir = (0, import_path.dirname)(this.filePath);
+      if (!(0, import_fs.existsSync)(dir)) {
+        (0, import_fs.mkdirSync)(dir, { recursive: true });
+      }
+      this.stream = (0, import_fs.createWriteStream)(this.filePath, { flags: "a" });
+      this.stream.on("error", (error) => {
+        console.error(`[SimpleTelemetry] Stream error: ${error.message}`);
+      });
+      console.log(`[SimpleTelemetry] File exporter initialized: ${this.filePath}`);
+    } catch (error) {
+      console.error(`[SimpleTelemetry] Failed to initialize file exporter: ${error.message}`);
+    }
+  }
+  createSpan(name, attributes = {}) {
+    const span = {
+      traceId: this.generateTraceId(),
+      spanId: this.generateSpanId(),
+      name,
+      startTime: Date.now(),
+      attributes: { ...attributes, service: this.serviceName },
+      events: [],
+      status: "OK"
+    };
+    return {
+      ...span,
+      addEvent: (eventName, eventAttributes = {}) => {
+        span.events.push({
+          name: eventName,
+          time: Date.now(),
+          attributes: eventAttributes
+        });
+      },
+      setAttributes: (attrs) => {
+        Object.assign(span.attributes, attrs);
+      },
+      setStatus: (status) => {
+        span.status = status;
+      },
+      end: () => {
+        span.endTime = Date.now();
+        span.duration = span.endTime - span.startTime;
+        this.exportSpan(span);
+      }
+    };
+  }
+  exportSpan(span) {
+    const spanData = {
+      ...span,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.enableConsole) {
+      console.log("[Trace]", JSON.stringify(spanData, null, 2));
+    }
+    if (this.enableFile && this.stream) {
+      this.stream.write(JSON.stringify(spanData) + "\n");
+    }
+  }
+  generateTraceId() {
+    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+  }
+  generateSpanId() {
+    return Math.random().toString(36).substring(2, 10);
+  }
+  async flush() {
+    if (this.stream) {
+      return new Promise((resolve) => {
+        this.stream.once("drain", resolve);
+        if (!this.stream.writableNeedDrain) {
+          resolve();
+        }
+      });
+    }
+  }
+  async shutdown() {
+    if (this.stream) {
+      return new Promise((resolve) => {
+        this.stream.end(() => {
+          console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
+          resolve();
+        });
+      });
+    }
+  }
+};
+var SimpleAppTracer = class {
+  constructor(telemetry, sessionId = null) {
+    this.telemetry = telemetry;
+    this.sessionId = sessionId || this.generateSessionId();
+  }
+  generateSessionId() {
+    return Math.random().toString(36).substring(2, 15);
+  }
+  isEnabled() {
+    return this.telemetry !== null;
+  }
+  createSessionSpan(attributes = {}) {
+    if (!this.isEnabled()) return null;
+    return this.telemetry.createSpan("agent.session", {
+      "session.id": this.sessionId,
+      ...attributes
+    });
+  }
+  createAISpan(modelName, provider, attributes = {}) {
+    if (!this.isEnabled()) return null;
+    return this.telemetry.createSpan("ai.request", {
+      "ai.model": modelName,
+      "ai.provider": provider,
+      "session.id": this.sessionId,
+      ...attributes
+    });
+  }
+  createToolSpan(toolName, attributes = {}) {
+    if (!this.isEnabled()) return null;
+    return this.telemetry.createSpan("tool.call", {
+      "tool.name": toolName,
+      "session.id": this.sessionId,
+      ...attributes
+    });
+  }
+  addEvent(name, attributes = {}) {
+    if (this.telemetry && this.telemetry.enableConsole) {
+      console.log("[Event]", name, 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
+    });
+  }
+  setAttributes(attributes) {
+    if (this.telemetry && this.telemetry.enableConsole) {
+      console.log("[Attributes]", attributes);
+    }
+  }
+  async withSpan(spanName, fn, attributes = {}) {
+    if (!this.isEnabled()) {
+      return fn();
+    }
+    const span = this.telemetry.createSpan(spanName, {
+      "session.id": this.sessionId,
+      ...attributes
+    });
+    try {
+      const result = await fn();
+      span.setStatus("OK");
+      return result;
+    } catch (error) {
+      span.setStatus("ERROR");
+      span.addEvent("exception", {
+        "exception.message": error.message,
+        "exception.stack": error.stack
+      });
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  async flush() {
+    if (this.telemetry) {
+      await this.telemetry.flush();
+    }
+  }
+  async shutdown() {
+    if (this.telemetry) {
+      await this.telemetry.shutdown();
+    }
+  }
+};
+function initializeSimpleTelemetryFromOptions(options) {
+  const telemetry = new SimpleTelemetry({
+    serviceName: "probe-agent",
+    enableFile: options.traceFile !== void 0,
+    enableConsole: options.traceConsole,
+    filePath: options.traceFile || "./traces.jsonl"
+  });
+  return telemetry;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SimpleAppTracer,
+  SimpleTelemetry,
+  initializeSimpleTelemetryFromOptions
+});

package/cjs/agent/telemetry.cjs

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