@probelabs/probe 0.6.0-rc147 → 0.6.0-rc149

package/src/agent/fileSpanExporter.js

@@ -1,167 +0,0 @@
-import { createWriteStream } from 'fs';
-import { ExportResultCode } from '@opentelemetry/core';
-
-/**
- * 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();
-      }
-    });
-  }
-}

package/src/agent/telemetry.js

@@ -1,219 +0,0 @@
-import { NodeSDK } from '@opentelemetry/sdk-node';
-import { resourceFromAttributes } from '@opentelemetry/resources';
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
-import { trace, context, SpanStatusCode } from '@opentelemetry/api';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { BatchSpanProcessor, ConsoleSpanExporter } from '@opentelemetry/sdk-trace-base';
-
-import { existsSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
-import { FileSpanExporter } from './fileSpanExporter.js';
-
-/**
- * Custom OpenTelemetry configuration for probe-agent
- */
-export class TelemetryConfig {
-  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 = resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: this.serviceName,
-      [ATTR_SERVICE_VERSION]: this.serviceVersion,
-    });
-
-    const spanProcessors = [];
-
-    // Add file exporter if enabled
-    if (this.enableFile) {
-      try {
-        // Ensure the directory exists
-        const dir = dirname(this.filePath);
-        if (!existsSync(dir)) {
-          mkdirSync(dir, { recursive: true });
-        }
-        
-        const fileExporter = new FileSpanExporter(this.filePath);
-        spanProcessors.push(new BatchSpanProcessor(fileExporter, {
-          maxQueueSize: 2048,
-          maxExportBatchSize: 512,
-          scheduledDelayMillis: 500,
-          exportTimeoutMillis: 30000,
-        }));
-        console.log(`[Telemetry] File exporter enabled, writing to: ${this.filePath}`);
-      } catch (error) {
-        console.error(`[Telemetry] Failed to initialize file exporter: ${error.message}`);
-      }
-    }
-
-    // Add remote exporter if enabled
-    if (this.enableRemote) {
-      try {
-        const remoteExporter = new OTLPTraceExporter({
-          url: this.remoteEndpoint,
-        });
-        spanProcessors.push(new BatchSpanProcessor(remoteExporter, {
-          maxQueueSize: 2048,
-          maxExportBatchSize: 512,
-          scheduledDelayMillis: 500,
-          exportTimeoutMillis: 30000,
-        }));
-        console.log(`[Telemetry] Remote exporter enabled, endpoint: ${this.remoteEndpoint}`);
-      } catch (error) {
-        console.error(`[Telemetry] Failed to initialize remote exporter: ${error.message}`);
-      }
-    }
-
-    // Add console exporter if enabled (useful for debugging)
-    if (this.enableConsole) {
-      const consoleExporter = new ConsoleSpanExporter();
-      spanProcessors.push(new BatchSpanProcessor(consoleExporter, {
-        maxQueueSize: 2048,
-        maxExportBatchSize: 512,
-        scheduledDelayMillis: 500,
-        exportTimeoutMillis: 30000,
-      }));
-      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 NodeSDK({
-      resource,
-      spanProcessors,
-    });
-
-    try {
-      this.sdk.start();
-      this.tracer = 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 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();
-      }
-    };
-  }
-
-  /**
-   * Force flush all pending spans
-   */
-  async forceFlush() {
-    if (this.sdk) {
-      try {
-        const tracerProvider = trace.getTracerProvider();
-        
-        if (tracerProvider && typeof tracerProvider.forceFlush === 'function') {
-          await tracerProvider.forceFlush();
-        }
-        
-        // Add a small delay to ensure file writes complete
-        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}`);
-      }
-    }
-  }
-}
-
-/**
- * Initialize telemetry from CLI options
- */
-export function initializeTelemetryFromOptions(options) {
-  const config = new TelemetryConfig({
-    serviceName: 'probe-agent',
-    serviceVersion: '1.0.0',
-    enableFile: options.traceFile !== undefined,
-    enableRemote: options.traceRemote !== undefined,
-    enableConsole: options.traceConsole,
-    filePath: options.traceFile || './traces.jsonl',
-    remoteEndpoint: options.traceRemote || 'http://localhost:4318/v1/traces',
-  });
-
-  config.initialize();
-  return config;
-}