@voltagent/core 1.1.14 → 1.1.15

package/dist/index.d.mts

@@ -2010,9 +2010,11 @@ interface VoltAgentStreamTextResult<TOOLS extends Record<string, any> = Record<s
 interface ObservabilityConfig {
     serviceName?: string;
     serviceVersion?: string;
+    instrumentationScopeName?: string;
     storage?: ObservabilityStorageAdapter;
     logger?: Logger;
     resourceAttributes?: Record<string, any>;
+    spanFilters?: SpanFilterConfig;
     voltOpsSync?: {
         sampling?: {
             strategy?: "always" | "never" | "ratio" | "parent";
@@ -2026,6 +2028,23 @@ interface ObservabilityConfig {
     spanProcessors?: SpanProcessor[];
     logProcessors?: LogRecordProcessor[];
 }
+/**
+ * Span filter configuration
+ */
+interface SpanFilterConfig {
+    enabled?: boolean;
+    /**
+     * Restrict span processing to spans originating from these tracer
+     * instrumentation scope names. Defaults to the internal VoltAgent tracer
+     * when omitted.
+     */
+    instrumentationScopeNames?: string[];
+    /**
+     * Restrict span processing to the provided `service.name` values. If empty
+     * or undefined, this constraint is ignored.
+     */
+    serviceNames?: string[];
+}
 /**
  * Unified span format for all observability features
  * Serializable and compatible with OpenTelemetry concepts
@@ -2201,11 +2220,15 @@ declare class VoltAgentObservability {
     private localStorageProcessor?;
     private config;
     private logger;
+    private spanFilterOptions?;
+    private instrumentationScopeName;
     constructor(config?: ObservabilityConfig);
     /**
      * Set up span processors
      */
     private setupProcessors;
+    private applySpanFilter;
+    private resolveSpanFilterOptions;
     /**
      * Try to initialize Pino OpenTelemetry bridge if available
      */

package/dist/index.d.ts

@@ -2010,9 +2010,11 @@ interface VoltAgentStreamTextResult<TOOLS extends Record<string, any> = Record<s
 interface ObservabilityConfig {
     serviceName?: string;
     serviceVersion?: string;
+    instrumentationScopeName?: string;
     storage?: ObservabilityStorageAdapter;
     logger?: Logger;
     resourceAttributes?: Record<string, any>;
+    spanFilters?: SpanFilterConfig;
     voltOpsSync?: {
         sampling?: {
             strategy?: "always" | "never" | "ratio" | "parent";
@@ -2026,6 +2028,23 @@ interface ObservabilityConfig {
     spanProcessors?: SpanProcessor[];
     logProcessors?: LogRecordProcessor[];
 }
+/**
+ * Span filter configuration
+ */
+interface SpanFilterConfig {
+    enabled?: boolean;
+    /**
+     * Restrict span processing to spans originating from these tracer
+     * instrumentation scope names. Defaults to the internal VoltAgent tracer
+     * when omitted.
+     */
+    instrumentationScopeNames?: string[];
+    /**
+     * Restrict span processing to the provided `service.name` values. If empty
+     * or undefined, this constraint is ignored.
+     */
+    serviceNames?: string[];
+}
 /**
  * Unified span format for all observability features
  * Serializable and compatible with OpenTelemetry concepts
@@ -2201,11 +2220,15 @@ declare class VoltAgentObservability {
     private localStorageProcessor?;
     private config;
     private logger;
+    private spanFilterOptions?;
+    private instrumentationScopeName;
     constructor(config?: ObservabilityConfig);
     /**
      * Set up span processors
      */
     private setupProcessors;
+    private applySpanFilter;
+    private resolveSpanFilterOptions;
     /**
      * Try to initialize Pino OpenTelemetry bridge if available
      */

package/dist/index.js

@@ -2640,7 +2640,7 @@ var import_api_logs3 = require("@opentelemetry/api-logs");
 var import_resources = require("@opentelemetry/resources");
 var import_sdk_logs2 = require("@opentelemetry/sdk-logs");
 var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
-var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var import_semantic_conventions2 = require("@opentelemetry/semantic-conventions");
 
 // src/observability/adapters/in-memory-adapter.ts
 var import_internal2 = require("@voltagent/internal");
@@ -3454,6 +3454,69 @@ var SamplingWrapperProcessor = class {
   }
 };
 
+// src/observability/processors/span-filter-processor.ts
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var SpanFilterProcessor = class {
+  constructor(delegate, options = {}) {
+    this.delegate = delegate;
+    this.options = options;
+    if (options.allowedServiceNames && options.allowedServiceNames.length > 0) {
+      this.allowedServiceNames = new Set(options.allowedServiceNames);
+    }
+    if (options.allowedInstrumentationScopes && options.allowedInstrumentationScopes.length > 0) {
+      this.allowedInstrumentationScopes = new Set(options.allowedInstrumentationScopes);
+    }
+  }
+  static {
+    __name(this, "SpanFilterProcessor");
+  }
+  allowedServiceNames;
+  allowedInstrumentationScopes;
+  onStart(span, parentContext) {
+    if (this.shouldProcess(span)) {
+      this.delegate.onStart(span, parentContext);
+    }
+  }
+  onEnd(span) {
+    if (this.shouldProcess(span)) {
+      this.delegate.onEnd(span);
+    }
+  }
+  async shutdown() {
+    await this.delegate.shutdown();
+  }
+  async forceFlush() {
+    await this.delegate.forceFlush();
+  }
+  shouldProcess(span) {
+    if (this.options.predicate) {
+      return this.options.predicate(span);
+    }
+    if (this.allowedInstrumentationScopes) {
+      const scopeName = this.extractInstrumentationScopeName(span);
+      if (!scopeName || !this.allowedInstrumentationScopes.has(scopeName)) {
+        return false;
+      }
+    }
+    if (!this.allowedServiceNames) {
+      return true;
+    }
+    const serviceName = this.extractServiceName(span);
+    return serviceName !== void 0 && this.allowedServiceNames.has(serviceName);
+  }
+  extractInstrumentationScopeName(span) {
+    const scope = span.instrumentationScope ?? span.instrumentationScope;
+    const value = scope?.name;
+    return typeof value === "string" ? value : void 0;
+  }
+  extractServiceName(span) {
+    const resource = span.resource ?? span.resource;
+    const attributes = resource?.attributes;
+    const value = attributes?.[import_semantic_conventions.ATTR_SERVICE_NAME];
+    return typeof value === "string" ? value : void 0;
+  }
+};
+
 // src/observability/processors/websocket-span-processor.ts
 var import_node_events3 = require("events");
 var import_api3 = require("@opentelemetry/api");
@@ -3569,9 +3632,29 @@ var VoltAgentObservability = class {
   localStorageProcessor;
   config;
   logger;
+  spanFilterOptions;
+  instrumentationScopeName;
   constructor(config = {}) {
     this.config = config;
     this.logger = getGlobalLogger();
+    this.instrumentationScopeName = config.instrumentationScopeName || "@voltagent/core";
+    this.spanFilterOptions = this.resolveSpanFilterOptions();
+    if (this.spanFilterOptions) {
+      const scopes = this.spanFilterOptions.allowedInstrumentationScopes ?? [];
+      const services = this.spanFilterOptions.allowedServiceNames ?? [];
+      const parts = [];
+      if (scopes.length > 0) {
+        parts.push(`instrumentation scopes [${scopes.join(", ")}]`);
+      }
+      if (services.length > 0) {
+        parts.push(`service.name values [${services.join(", ")}]`);
+      }
+      this.logger.trace(
+        `[VoltAgent] Observability span filtering active for ${parts.join(" and ")}`
+      );
+    } else {
+      this.logger.trace("[VoltAgent] Observability span filtering disabled");
+    }
     this.storage = config.storage || new InMemoryStorageAdapter2({
       maxSpans: 1e4,
       cleanupIntervalMs: 6e4
@@ -3579,8 +3662,8 @@ var VoltAgentObservability = class {
     });
     const resource = (0, import_resources.defaultResource)().merge(
       (0, import_resources.resourceFromAttributes)({
-        [import_semantic_conventions.ATTR_SERVICE_NAME]: config.serviceName || "voltagent",
-        [import_semantic_conventions.ATTR_SERVICE_VERSION]: config.serviceVersion || "1.0.0",
+        [import_semantic_conventions2.ATTR_SERVICE_NAME]: config.serviceName || "voltagent",
+        [import_semantic_conventions2.ATTR_SERVICE_VERSION]: config.serviceVersion || "1.0.0",
         ...config.resourceAttributes
       })
     );
@@ -3590,10 +3673,7 @@ var VoltAgentObservability = class {
       spanProcessors
     });
     this.provider.register();
-    this.tracer = import_api4.trace.getTracer(
-      config.serviceName || "voltagent",
-      config.serviceVersion || "1.0.0"
-    );
+    this.tracer = import_api4.trace.getTracer(this.instrumentationScopeName, config.serviceVersion || "1.0.0");
     const logProcessors = this.setupLogProcessors();
     this.loggerProvider = new import_sdk_logs2.LoggerProvider({
       resource,
@@ -3613,9 +3693,9 @@ var VoltAgentObservability = class {
   setupProcessors() {
     const processors = [];
     this.websocketProcessor = new WebSocketSpanProcessor(true);
-    processors.push(this.websocketProcessor);
+    processors.push(this.applySpanFilter(this.websocketProcessor));
     this.localStorageProcessor = new LocalStorageSpanProcessor(this.storage);
-    processors.push(this.localStorageProcessor);
+    processors.push(this.applySpanFilter(this.localStorageProcessor));
     const samplingStrategy = this.config.voltOpsSync?.sampling?.strategy || "always";
     if (samplingStrategy !== "never") {
       const lazyProcessor = new LazyRemoteExportProcessor({
@@ -3626,7 +3706,7 @@ var VoltAgentObservability = class {
         logger: this.logger
       });
       const finalProcessor = samplingStrategy === "always" ? lazyProcessor : new SamplingWrapperProcessor(lazyProcessor, this.config.voltOpsSync?.sampling);
-      processors.push(finalProcessor);
+      processors.push(this.applySpanFilter(finalProcessor));
       this.logger.debug(
         `[VoltAgent] VoltOps sync enabled with ${samplingStrategy} sampling strategy`
       );
@@ -3637,10 +3717,42 @@ var VoltAgentObservability = class {
       }
     }
     if (this.config.spanProcessors) {
-      processors.push(...this.config.spanProcessors);
+      processors.push(
+        ...this.config.spanProcessors.map((processor) => this.applySpanFilter(processor))
+      );
     }
     return processors;
   }
+  applySpanFilter(processor) {
+    if (!this.spanFilterOptions) {
+      return processor;
+    }
+    if (processor instanceof SpanFilterProcessor) {
+      return processor;
+    }
+    return new SpanFilterProcessor(processor, this.spanFilterOptions);
+  }
+  resolveSpanFilterOptions() {
+    const filterConfig = this.config.spanFilters;
+    if (filterConfig?.enabled === false) {
+      return void 0;
+    }
+    const instrumentationScopes = filterConfig?.instrumentationScopeNames ?? [
+      this.instrumentationScopeName
+    ];
+    const serviceNames = filterConfig?.serviceNames;
+    const options = {};
+    if (instrumentationScopes && instrumentationScopes.length > 0) {
+      options.allowedInstrumentationScopes = instrumentationScopes;
+    }
+    if (serviceNames && serviceNames.length > 0) {
+      options.allowedServiceNames = serviceNames;
+    }
+    if (!options.allowedInstrumentationScopes && !options.allowedServiceNames) {
+      return void 0;
+    }
+    return options;
+  }
   /**
    * Try to initialize Pino OpenTelemetry bridge if available
    */