@bsb/observable-opentelemetry 9.0.0

package/README.md

@@ -0,0 +1,58 @@
+# @bsb/observable-opentelemetry
+
+OpenTelemetry observable plugin for BSB with full OTLP export support for traces, metrics, and logs.
+
+## Installation
+
+```bash
+npm install @bsb/observable-opentelemetry
+```
+
+## Features
+
+- **Full OpenTelemetry integration** - Traces, metrics, and logs
+- **OTLP export** - HTTP and gRPC protocol support
+- **Resource attributes** - Customizable service metadata
+- **Configurable sampling** - Control trace collection rates
+- **Batch processing** - Efficient data export with batching
+
+## Configuration
+
+```yaml
+plugins:
+  observables:
+    - plugin: "@bsb/observable-opentelemetry"
+      enabled: true
+      config:
+        serviceName: "my-service"
+        serviceVersion: "1.0.0"
+        endpoint: "http://localhost:4318"
+        export:
+          protocol: "http"
+          interval: 5000
+          maxBatchSize: 512
+        enabled:
+          traces: true
+          metrics: true
+          logs: true
+        resourceAttributes:
+          environment: "production"
+          region: "us-east-1"
+        samplingRate: 1.0
+```
+
+### Configuration Options
+
+- **serviceName**: Name of your service
+- **serviceVersion**: Version of your service
+- **endpoint**: OTLP collector endpoint URL
+- **export.protocol**: "http" or "grpc"
+- **export.interval**: Export interval in milliseconds
+- **export.maxBatchSize**: Maximum batch size for exports
+- **enabled**: Toggle traces, metrics, and logs individually
+- **resourceAttributes**: Custom resource attributes
+- **samplingRate**: Trace sampling rate (0.0 to 1.0)
+
+## License
+
+Dual-licensed under AGPL-3.0-only OR Commercial License.

package/lib/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+export * from "./plugins/observable-opentelemetry";

package/lib/index.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./plugins/observable-opentelemetry"), exports);

package/lib/plugins/observable-opentelemetry/index.d.ts

@@ -0,0 +1,134 @@
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { BSBObservable, BSBObservableConstructor, BSBError } from "@bsb/base";
+import { DTrace, LogMeta } from "@bsb/base";
+import { z } from "zod";
+/**
+ * Configuration schema for OpenTelemetry plugin
+ */
+export declare const OpenTelemetryConfigSchema: z.ZodObject<{
+    serviceName: z.ZodDefault<z.ZodString>;
+    serviceVersion: z.ZodOptional<z.ZodString>;
+    endpoint: z.ZodDefault<z.ZodString>;
+    export: z.ZodObject<{
+        protocol: z.ZodDefault<z.ZodEnum<{
+            http: "http";
+            grpc: "grpc";
+        }>>;
+        interval: z.ZodDefault<z.ZodNumber>;
+        maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    enabled: z.ZodObject<{
+        traces: z.ZodDefault<z.ZodBoolean>;
+        metrics: z.ZodDefault<z.ZodBoolean>;
+        logs: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    resourceAttributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    samplingRate: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type OpenTelemetryConfig = z.infer<typeof OpenTelemetryConfigSchema>;
+export declare const Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObject<{
+    serviceName: z.ZodDefault<z.ZodString>;
+    serviceVersion: z.ZodOptional<z.ZodString>;
+    endpoint: z.ZodDefault<z.ZodString>;
+    export: z.ZodObject<{
+        protocol: z.ZodDefault<z.ZodEnum<{
+            http: "http";
+            grpc: "grpc";
+        }>>;
+        interval: z.ZodDefault<z.ZodNumber>;
+        maxBatchSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    enabled: z.ZodObject<{
+        traces: z.ZodDefault<z.ZodBoolean>;
+        metrics: z.ZodDefault<z.ZodBoolean>;
+        logs: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    resourceAttributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    samplingRate: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>>;
+/**
+ * OpenTelemetry observable plugin with OTLP export
+ */
+export declare class Plugin extends BSBObservable<InstanceType<typeof Config>> {
+    static Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObject<{
+        serviceName: z.ZodDefault<z.ZodString>;
+        serviceVersion: z.ZodOptional<z.ZodString>;
+        endpoint: z.ZodDefault<z.ZodString>;
+        export: z.ZodObject<{
+            protocol: z.ZodDefault<z.ZodEnum<{
+                http: "http";
+                grpc: "grpc";
+            }>>;
+            interval: z.ZodDefault<z.ZodNumber>;
+            maxBatchSize: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        enabled: z.ZodObject<{
+            traces: z.ZodDefault<z.ZodBoolean>;
+            metrics: z.ZodDefault<z.ZodBoolean>;
+            logs: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>;
+        resourceAttributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        samplingRate: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    private logFormatter;
+    private sdk;
+    private tracer;
+    private meter;
+    private logger;
+    private loggerProvider;
+    private isDisposed;
+    private counters;
+    private gauges;
+    private histograms;
+    private spans;
+    constructor(config: BSBObservableConstructor<InstanceType<typeof Config>>);
+    init(): Promise<void>;
+    run(): Promise<void>;
+    /**
+     * Map DTrace to OpenTelemetry trace context
+     */
+    private getTraceContext;
+    /**
+     * Write log entry via OpenTelemetry
+     */
+    private writeLog;
+    debug(trace: DTrace, pluginName: string, message: string, meta: LogMeta<any>): void;
+    info(trace: DTrace, pluginName: string, message: string, meta: LogMeta<any>): void;
+    warn(trace: DTrace, pluginName: string, message: string, meta: LogMeta<any>): void;
+    error(trace: DTrace, pluginName: string, message: string | BSBError<any>, meta?: LogMeta<any>): void;
+    createCounter(timestamp: number, pluginName: string, name: string, description: string, help: string, labels?: string[]): void;
+    incrementCounter(timestamp: number, pluginName: string, name: string, value: number, labels?: Record<string, string>): void;
+    createGauge(timestamp: number, pluginName: string, name: string, description: string, help: string, labels?: string[]): void;
+    setGauge(timestamp: number, pluginName: string, name: string, value: number, labels?: Record<string, string>): void;
+    createHistogram(timestamp: number, pluginName: string, name: string, description: string, help: string, boundaries?: number[], labels?: string[]): void;
+    observeHistogram(timestamp: number, pluginName: string, name: string, value: number, labels?: Record<string, string>): void;
+    spanStart(trace: DTrace, pluginName: string, spanName: string, parentSpanId: string | null, attributes?: Record<string, string | number | boolean>): void;
+    spanEnd(trace: DTrace, pluginName: string, attributes?: Record<string, string | number | boolean>): void;
+    spanError(trace: DTrace, pluginName: string, error: Error, attributes?: Record<string, string | number | boolean>): void;
+    dispose(): Promise<void>;
+}

package/lib/plugins/observable-opentelemetry/index.js

@@ -0,0 +1,401 @@
+"use strict";
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = exports.Config = exports.OpenTelemetryConfigSchema = void 0;
+const base_1 = require("@bsb/base");
+const zod_1 = require("zod");
+const api = __importStar(require("@opentelemetry/api"));
+const resources_1 = require("@opentelemetry/resources");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
+const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+/**
+ * Configuration schema for OpenTelemetry plugin
+ */
+exports.OpenTelemetryConfigSchema = zod_1.z.object({
+    serviceName: zod_1.z.string().default("bsb-service"),
+    serviceVersion: zod_1.z.string().optional(),
+    endpoint: zod_1.z.string().url().default("http://localhost:4318"),
+    export: zod_1.z.object({
+        protocol: zod_1.z.enum(["http", "grpc"]).default("http"),
+        interval: zod_1.z.number().int().min(100).default(5000),
+        maxBatchSize: zod_1.z.number().int().min(1).default(512),
+    }),
+    enabled: zod_1.z.object({
+        traces: zod_1.z.boolean().default(true),
+        metrics: zod_1.z.boolean().default(true),
+        logs: zod_1.z.boolean().default(true),
+    }),
+    resourceAttributes: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).default({}),
+    samplingRate: zod_1.z.number().min(0).max(1).default(1.0),
+});
+exports.Config = (0, base_1.createConfigSchema)({
+    name: 'observable-opentelemetry',
+    description: 'OpenTelemetry integration for logs, metrics, and traces via OTLP',
+    version: '9.0.0',
+    image: './observable-opentelemetry.png',
+    tags: ['opentelemetry', 'otlp', 'observability', 'logs', 'metrics', 'traces'],
+    documentation: ['./docs/plugin.md'],
+}, exports.OpenTelemetryConfigSchema);
+/**
+ * Convert BSB log level to OpenTelemetry severity number
+ */
+function bsbLevelToOtelSeverity(level) {
+    const normalized = level.toLowerCase();
+    switch (normalized) {
+        case "debug":
+            return 5; // DEBUG
+        case "info":
+            return 9; // INFO
+        case "warn":
+        case "warning":
+            return 13; // WARN
+        case "error":
+            return 17; // ERROR
+        default:
+            return 9; // Default to INFO
+    }
+}
+/**
+ * Convert BSB log level to OpenTelemetry severity text
+ */
+function bsbLevelToOtelSeverityText(level) {
+    const normalized = level.toLowerCase();
+    switch (normalized) {
+        case "debug":
+            return "DEBUG";
+        case "info":
+            return "INFO";
+        case "warn":
+        case "warning":
+            return "WARN";
+        case "error":
+            return "ERROR";
+        default:
+            return "INFO";
+    }
+}
+/**
+ * OpenTelemetry observable plugin with OTLP export
+ */
+class Plugin extends base_1.BSBObservable {
+    static Config = exports.Config;
+    logFormatter = new base_1.LogFormatter();
+    sdk = null;
+    tracer = null;
+    meter = null;
+    logger = null;
+    loggerProvider = null;
+    isDisposed = false;
+    // Cache for metrics
+    counters = new Map();
+    gauges = new Map();
+    histograms = new Map();
+    // Cache for active spans
+    spans = new Map();
+    constructor(config) {
+        super(config);
+    }
+    async init() {
+        // Create resource with service information
+        const resource = new resources_1.Resource({
+            [semantic_conventions_1.ATTR_SERVICE_NAME]: this.config.serviceName,
+            ...(this.config.serviceVersion && { [semantic_conventions_1.ATTR_SERVICE_VERSION]: this.config.serviceVersion }),
+            ...this.config.resourceAttributes,
+        });
+        // Configure exporters
+        const traceExporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({
+            url: `${this.config.endpoint}/v1/traces`,
+        });
+        const metricExporter = new exporter_metrics_otlp_http_1.OTLPMetricExporter({
+            url: `${this.config.endpoint}/v1/metrics`,
+        });
+        const logExporter = new exporter_logs_otlp_http_1.OTLPLogExporter({
+            url: `${this.config.endpoint}/v1/logs`,
+        });
+        // Initialize SDK
+        this.sdk = new sdk_node_1.NodeSDK({
+            resource,
+            traceExporter: this.config.enabled.traces ? traceExporter : undefined,
+        });
+        await this.sdk.start();
+        // Get tracer
+        if (this.config.enabled.traces) {
+            this.tracer = api.trace.getTracer(this.config.serviceName, this.config.serviceVersion);
+        }
+        // Setup metrics separately
+        if (this.config.enabled.metrics) {
+            const meterProvider = new sdk_metrics_1.MeterProvider({ resource });
+            meterProvider.addMetricReader(new sdk_metrics_1.PeriodicExportingMetricReader({
+                exporter: metricExporter,
+                exportIntervalMillis: this.config.export.interval,
+            }));
+            this.meter = meterProvider.getMeter(this.config.serviceName, this.config.serviceVersion);
+        }
+        // Setup logs separately
+        if (this.config.enabled.logs) {
+            this.loggerProvider = new sdk_logs_1.LoggerProvider({ resource });
+            this.loggerProvider.addLogRecordProcessor(new sdk_logs_1.BatchLogRecordProcessor(logExporter));
+            this.logger = this.loggerProvider.getLogger(this.config.serviceName, this.config.serviceVersion);
+        }
+    }
+    async run() {
+        // No runtime setup needed
+    }
+    /**
+     * Map DTrace to OpenTelemetry trace context
+     */
+    getTraceContext(trace) {
+        // Convert DTrace.t (trace ID) and DTrace.s (span ID) to OpenTelemetry format
+        // BSB uses string IDs, OpenTelemetry uses hex format
+        const traceId = trace.t.padStart(32, "0").substring(0, 32);
+        const spanId = trace.s.padStart(16, "0").substring(0, 16);
+        const spanContext = {
+            traceId,
+            spanId,
+            traceFlags: api.TraceFlags.SAMPLED,
+        };
+        return api.trace.setSpanContext(api.context.active(), spanContext);
+    }
+    /**
+     * Write log entry via OpenTelemetry
+     */
+    writeLog(level, trace, pluginName, message, meta) {
+        if (!this.logger || this.isDisposed) {
+            return;
+        }
+        const formattedMessage = this.logFormatter.formatLog(trace, message, meta);
+        const context = this.getTraceContext(trace);
+        this.logger.emit({
+            severityNumber: bsbLevelToOtelSeverity(level),
+            severityText: bsbLevelToOtelSeverityText(level),
+            body: formattedMessage,
+            attributes: {
+                "bsb.plugin": pluginName,
+                "bsb.trace.t": trace.t,
+                "bsb.trace.s": trace.s,
+                ...(meta && Object.keys(meta).length > 0 ? { "bsb.meta": JSON.stringify(meta) } : {}),
+            },
+            context,
+        });
+    }
+    // Logging methods
+    debug(trace, pluginName, message, meta) {
+        if (this.mode === "production") {
+            return;
+        }
+        this.writeLog("debug", trace, pluginName, message, meta);
+    }
+    info(trace, pluginName, message, meta) {
+        this.writeLog("info", trace, pluginName, message, meta);
+    }
+    warn(trace, pluginName, message, meta) {
+        this.writeLog("warn", trace, pluginName, message, meta);
+    }
+    error(trace, pluginName, message, meta) {
+        if (message instanceof base_1.BSBError) {
+            if (message.raw !== null) {
+                this.writeLog("error", message.raw.trace, pluginName, message.raw.message, message.raw.meta);
+            }
+            else {
+                this.writeLog("error", trace, pluginName, message.message);
+            }
+        }
+        else {
+            this.writeLog("error", trace, pluginName, message, meta);
+        }
+    }
+    // Metrics methods
+    createCounter(timestamp, pluginName, name, description, help, labels) {
+        if (!this.meter || this.isDisposed) {
+            return;
+        }
+        const fullName = `${pluginName}.${name}`;
+        if (!this.counters.has(fullName)) {
+            const counter = this.meter.createCounter(fullName, {
+                description: description || help,
+            });
+            this.counters.set(fullName, counter);
+        }
+    }
+    incrementCounter(timestamp, pluginName, name, value, labels) {
+        if (!this.meter || this.isDisposed) {
+            return;
+        }
+        const fullName = `${pluginName}.${name}`;
+        const counter = this.counters.get(fullName);
+        if (counter) {
+            counter.add(value, labels);
+        }
+    }
+    createGauge(timestamp, pluginName, name, description, help, labels) {
+        if (!this.meter || this.isDisposed) {
+            return;
+        }
+        const fullName = `${pluginName}.${name}`;
+        if (!this.gauges.has(fullName)) {
+            let currentValue = 0;
+            const gauge = this.meter.createObservableGauge(fullName, {
+                description: description || help,
+            });
+            gauge.addCallback((observableResult) => {
+                observableResult.observe(currentValue);
+            });
+            this.gauges.set(fullName, gauge);
+        }
+    }
+    setGauge(timestamp, pluginName, name, value, labels) {
+        // OpenTelemetry ObservableGauge doesn't support direct setting
+        // Would need to use UpDownCounter instead or maintain state
+        // For now, log a warning
+        console.warn(`[observable-opentelemetry] setGauge not fully supported in OpenTelemetry, use UpDownCounter`);
+    }
+    createHistogram(timestamp, pluginName, name, description, help, boundaries, labels) {
+        if (!this.meter || this.isDisposed) {
+            return;
+        }
+        const fullName = `${pluginName}.${name}`;
+        if (!this.histograms.has(fullName)) {
+            const histogram = this.meter.createHistogram(fullName, {
+                description: description || help,
+            });
+            this.histograms.set(fullName, histogram);
+        }
+    }
+    observeHistogram(timestamp, pluginName, name, value, labels) {
+        if (!this.meter || this.isDisposed) {
+            return;
+        }
+        const fullName = `${pluginName}.${name}`;
+        const histogram = this.histograms.get(fullName);
+        if (histogram) {
+            histogram.record(value, labels);
+        }
+    }
+    // Tracing methods
+    spanStart(trace, pluginName, spanName, parentSpanId, attributes) {
+        if (!this.tracer || this.isDisposed) {
+            return;
+        }
+        const context = this.getTraceContext(trace);
+        const span = this.tracer.startSpan(spanName, {
+            attributes: {
+                "bsb.plugin": pluginName,
+                ...(parentSpanId ? { "bsb.parent_span_id": parentSpanId } : {}),
+                ...attributes,
+            },
+        }, context);
+        const spanKey = `${trace.t}:${trace.s}`;
+        this.spans.set(spanKey, span);
+    }
+    spanEnd(trace, pluginName, attributes) {
+        if (this.isDisposed) {
+            return;
+        }
+        const spanKey = `${trace.t}:${trace.s}`;
+        const span = this.spans.get(spanKey);
+        if (span) {
+            if (attributes) {
+                span.setAttributes(attributes);
+            }
+            span.end();
+            this.spans.delete(spanKey);
+        }
+    }
+    spanError(trace, pluginName, error, attributes) {
+        if (this.isDisposed) {
+            return;
+        }
+        const spanKey = `${trace.t}:${trace.s}`;
+        const span = this.spans.get(spanKey);
+        if (span) {
+            span.recordException(error);
+            span.setStatus({ code: api.SpanStatusCode.ERROR, message: error.message });
+            if (attributes) {
+                span.setAttributes(attributes);
+            }
+        }
+    }
+    async dispose() {
+        this.isDisposed = true;
+        // End all active spans
+        for (const span of this.spans.values()) {
+            span.end();
+        }
+        this.spans.clear();
+        // Shutdown SDK
+        if (this.sdk) {
+            await this.sdk.shutdown();
+            this.sdk = null;
+        }
+        this.tracer = null;
+        this.meter = null;
+        this.logger = null;
+        this.counters.clear();
+        this.gauges.clear();
+        this.histograms.clear();
+    }
+}
+exports.Plugin = Plugin;