feat: Complete zCode CLI X with Telegram bot integration

- Add full Telegram bot functionality with Z.AI API integration
- Implement 4 tools: Bash, FileEdit, WebSearch, Git
- Add 3 agents: Code Reviewer, Architect, DevOps Engineer
- Add 6 skills for common coding tasks
- Add systemd service file for 24/7 operation
- Add nginx configuration for HTTPS webhook
- Add comprehensive documentation
- Implement WebSocket server for real-time updates
- Add logging system with Winston
- Add environment validation

🤖 zCode CLI X - Agentic coder with Z.AI + Telegram integration

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/BatchSpanProcessorBase.d.ts

@@ -0,0 +1,41 @@
+import type { Context } from '@opentelemetry/api';
+import type { Span } from '../Span';
+import type { SpanProcessor } from '../SpanProcessor';
+import type { BufferConfig } from '../types';
+import type { ReadableSpan } from './ReadableSpan';
+import type { SpanExporter } from './SpanExporter';
+/**
+ * Implementation of the {@link SpanProcessor} that batches spans exported by
+ * the SDK then pushes them to the exporter pipeline.
+ */
+export declare abstract class BatchSpanProcessorBase<T extends BufferConfig> implements SpanProcessor {
+    private readonly _maxExportBatchSize;
+    private readonly _maxQueueSize;
+    private readonly _scheduledDelayMillis;
+    private readonly _exportTimeoutMillis;
+    private readonly _exporter;
+    private _isExporting;
+    private _finishedSpans;
+    private _timer;
+    private _shutdownOnce;
+    private _droppedSpansCount;
+    constructor(exporter: SpanExporter, config?: T);
+    forceFlush(): Promise<void>;
+    onStart(_span: Span, _parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+    private _shutdown;
+    /** Add a span in the buffer. */
+    private _addToBuffer;
+    /**
+     * Send all spans to the exporter respecting the batch size limit
+     * This function is used only on forceFlush or shutdown,
+     * for all other cases _flush should be used
+     * */
+    private _flushAll;
+    private _flushOneBatch;
+    private _maybeStartTimer;
+    private _clearTimer;
+    protected abstract onShutdown(): void;
+}
+//# sourceMappingURL=BatchSpanProcessorBase.d.ts.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/BatchSpanProcessorBase.js

@@ -0,0 +1,212 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchSpanProcessorBase = void 0;
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+/**
+ * Implementation of the {@link SpanProcessor} that batches spans exported by
+ * the SDK then pushes them to the exporter pipeline.
+ */
+class BatchSpanProcessorBase {
+    _maxExportBatchSize;
+    _maxQueueSize;
+    _scheduledDelayMillis;
+    _exportTimeoutMillis;
+    _exporter;
+    _isExporting = false;
+    _finishedSpans = [];
+    _timer;
+    _shutdownOnce;
+    _droppedSpansCount = 0;
+    constructor(exporter, config) {
+        this._exporter = exporter;
+        this._maxExportBatchSize =
+            typeof config?.maxExportBatchSize === 'number'
+                ? config.maxExportBatchSize
+                : ((0, core_1.getNumberFromEnv)('OTEL_BSP_MAX_EXPORT_BATCH_SIZE') ?? 512);
+        this._maxQueueSize =
+            typeof config?.maxQueueSize === 'number'
+                ? config.maxQueueSize
+                : ((0, core_1.getNumberFromEnv)('OTEL_BSP_MAX_QUEUE_SIZE') ?? 2048);
+        this._scheduledDelayMillis =
+            typeof config?.scheduledDelayMillis === 'number'
+                ? config.scheduledDelayMillis
+                : ((0, core_1.getNumberFromEnv)('OTEL_BSP_SCHEDULE_DELAY') ?? 5000);
+        this._exportTimeoutMillis =
+            typeof config?.exportTimeoutMillis === 'number'
+                ? config.exportTimeoutMillis
+                : ((0, core_1.getNumberFromEnv)('OTEL_BSP_EXPORT_TIMEOUT') ?? 30000);
+        this._shutdownOnce = new core_1.BindOnceFuture(this._shutdown, this);
+        if (this._maxExportBatchSize > this._maxQueueSize) {
+            api_1.diag.warn('BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize');
+            this._maxExportBatchSize = this._maxQueueSize;
+        }
+    }
+    forceFlush() {
+        if (this._shutdownOnce.isCalled) {
+            return this._shutdownOnce.promise;
+        }
+        return this._flushAll();
+    }
+    // does nothing.
+    onStart(_span, _parentContext) { }
+    onEnd(span) {
+        if (this._shutdownOnce.isCalled) {
+            return;
+        }
+        if ((span.spanContext().traceFlags & api_1.TraceFlags.SAMPLED) === 0) {
+            return;
+        }
+        this._addToBuffer(span);
+    }
+    shutdown() {
+        return this._shutdownOnce.call();
+    }
+    _shutdown() {
+        return Promise.resolve()
+            .then(() => {
+            return this.onShutdown();
+        })
+            .then(() => {
+            return this._flushAll();
+        })
+            .then(() => {
+            return this._exporter.shutdown();
+        });
+    }
+    /** Add a span in the buffer. */
+    _addToBuffer(span) {
+        if (this._finishedSpans.length >= this._maxQueueSize) {
+            // limit reached, drop span
+            if (this._droppedSpansCount === 0) {
+                api_1.diag.debug('maxQueueSize reached, dropping spans');
+            }
+            this._droppedSpansCount++;
+            return;
+        }
+        if (this._droppedSpansCount > 0) {
+            // some spans were dropped, log once with count of spans dropped
+            api_1.diag.warn(`Dropped ${this._droppedSpansCount} spans because maxQueueSize reached`);
+            this._droppedSpansCount = 0;
+        }
+        this._finishedSpans.push(span);
+        this._maybeStartTimer();
+    }
+    /**
+     * Send all spans to the exporter respecting the batch size limit
+     * This function is used only on forceFlush or shutdown,
+     * for all other cases _flush should be used
+     * */
+    _flushAll() {
+        return new Promise((resolve, reject) => {
+            const promises = [];
+            // calculate number of batches
+            const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
+            for (let i = 0, j = count; i < j; i++) {
+                promises.push(this._flushOneBatch());
+            }
+            Promise.all(promises)
+                .then(() => {
+                resolve();
+            })
+                .catch(reject);
+        });
+    }
+    _flushOneBatch() {
+        this._clearTimer();
+        if (this._finishedSpans.length === 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                // don't wait anymore for export, this way the next batch can start
+                reject(new Error('Timeout'));
+            }, this._exportTimeoutMillis);
+            // prevent downstream exporter calls from generating spans
+            api_1.context.with((0, core_1.suppressTracing)(api_1.context.active()), () => {
+                // Reset the finished spans buffer here because the next invocations of the _flush method
+                // could pass the same finished spans to the exporter if the buffer is cleared
+                // outside the execution of this callback.
+                let spans;
+                if (this._finishedSpans.length <= this._maxExportBatchSize) {
+                    spans = this._finishedSpans;
+                    this._finishedSpans = [];
+                }
+                else {
+                    spans = this._finishedSpans.splice(0, this._maxExportBatchSize);
+                }
+                const doExport = () => this._exporter.export(spans, result => {
+                    clearTimeout(timer);
+                    if (result.code === core_1.ExportResultCode.SUCCESS) {
+                        resolve();
+                    }
+                    else {
+                        reject(result.error ??
+                            new Error('BatchSpanProcessor: span export failed'));
+                    }
+                });
+                let pendingResources = null;
+                for (let i = 0, len = spans.length; i < len; i++) {
+                    const span = spans[i];
+                    if (span.resource.asyncAttributesPending &&
+                        span.resource.waitForAsyncAttributes) {
+                        pendingResources ??= [];
+                        pendingResources.push(span.resource.waitForAsyncAttributes());
+                    }
+                }
+                // Avoid scheduling a promise to make the behavior more predictable and easier to test
+                if (pendingResources === null) {
+                    doExport();
+                }
+                else {
+                    Promise.all(pendingResources).then(doExport, err => {
+                        (0, core_1.globalErrorHandler)(err);
+                        reject(err);
+                    });
+                }
+            });
+        });
+    }
+    _maybeStartTimer() {
+        if (this._isExporting)
+            return;
+        const flush = () => {
+            this._isExporting = true;
+            this._flushOneBatch()
+                .finally(() => {
+                this._isExporting = false;
+                if (this._finishedSpans.length > 0) {
+                    this._clearTimer();
+                    this._maybeStartTimer();
+                }
+            })
+                .catch(e => {
+                this._isExporting = false;
+                (0, core_1.globalErrorHandler)(e);
+            });
+        };
+        // we only wait if the queue doesn't have enough elements yet
+        if (this._finishedSpans.length >= this._maxExportBatchSize) {
+            return flush();
+        }
+        if (this._timer !== undefined)
+            return;
+        this._timer = setTimeout(() => flush(), this._scheduledDelayMillis);
+        // depending on runtime, this may be a 'number' or NodeJS.Timeout
+        if (typeof this._timer !== 'number') {
+            this._timer.unref();
+        }
+    }
+    _clearTimer() {
+        if (this._timer !== undefined) {
+            clearTimeout(this._timer);
+            this._timer = undefined;
+        }
+    }
+}
+exports.BatchSpanProcessorBase = BatchSpanProcessorBase;
+//# sourceMappingURL=BatchSpanProcessorBase.js.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/ConsoleSpanExporter.d.ts

@@ -0,0 +1,37 @@
+import type { SpanExporter } from './SpanExporter';
+import type { ReadableSpan } from './ReadableSpan';
+import type { ExportResult } from '@opentelemetry/core';
+/**
+ * This is implementation of {@link SpanExporter} that prints spans to the
+ * console. This class can be used for diagnostic purposes.
+ *
+ * NOTE: This {@link SpanExporter} is intended for diagnostics use only, output rendered to the console may change at any time.
+ */
+export declare class ConsoleSpanExporter implements SpanExporter {
+    /**
+     * Export spans.
+     * @param spans
+     * @param resultCallback
+     */
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    /**
+     * Shutdown the exporter.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Exports any pending spans in exporter
+     */
+    forceFlush(): Promise<void>;
+    /**
+     * converts span info into more readable format
+     * @param span
+     */
+    private _exportInfo;
+    /**
+     * Showing spans in console
+     * @param spans
+     * @param done
+     */
+    private _sendSpans;
+}
+//# sourceMappingURL=ConsoleSpanExporter.d.ts.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/ConsoleSpanExporter.js

@@ -0,0 +1,77 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleSpanExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+/**
+ * This is implementation of {@link SpanExporter} that prints spans to the
+ * console. This class can be used for diagnostic purposes.
+ *
+ * NOTE: This {@link SpanExporter} is intended for diagnostics use only, output rendered to the console may change at any time.
+ */
+/* eslint-disable no-console */
+class ConsoleSpanExporter {
+    /**
+     * Export spans.
+     * @param spans
+     * @param resultCallback
+     */
+    export(spans, resultCallback) {
+        return this._sendSpans(spans, resultCallback);
+    }
+    /**
+     * Shutdown the exporter.
+     */
+    shutdown() {
+        this._sendSpans([]);
+        return this.forceFlush();
+    }
+    /**
+     * Exports any pending spans in exporter
+     */
+    forceFlush() {
+        return Promise.resolve();
+    }
+    /**
+     * converts span info into more readable format
+     * @param span
+     */
+    _exportInfo(span) {
+        return {
+            resource: {
+                attributes: span.resource.attributes,
+            },
+            instrumentationScope: span.instrumentationScope,
+            traceId: span.spanContext().traceId,
+            parentSpanContext: span.parentSpanContext,
+            traceState: span.spanContext().traceState?.serialize(),
+            name: span.name,
+            id: span.spanContext().spanId,
+            kind: span.kind,
+            timestamp: (0, core_1.hrTimeToMicroseconds)(span.startTime),
+            duration: (0, core_1.hrTimeToMicroseconds)(span.duration),
+            attributes: span.attributes,
+            status: span.status,
+            events: span.events,
+            links: span.links,
+        };
+    }
+    /**
+     * Showing spans in console
+     * @param spans
+     * @param done
+     */
+    _sendSpans(spans, done) {
+        for (const span of spans) {
+            console.dir(this._exportInfo(span), { depth: 3 });
+        }
+        if (done) {
+            return done({ code: core_1.ExportResultCode.SUCCESS });
+        }
+    }
+}
+exports.ConsoleSpanExporter = ConsoleSpanExporter;
+//# sourceMappingURL=ConsoleSpanExporter.js.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/ConsoleSpanExporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleSpanExporter.js","sourceRoot":"","sources":["../../../src/export/ConsoleSpanExporter.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAKH,8CAA6E;AAE7E;;;;;GAKG;AAEH,+BAA+B;AAC/B,MAAa,mBAAmB;IAC9B;;;;OAIG;IACH,MAAM,CACJ,KAAqB,EACrB,cAA8C;QAE9C,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QACpB,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,UAAU;QACR,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACK,WAAW,CAAC,IAAkB;QACpC,OAAO;YACL,QAAQ,EAAE;gBACR,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU;aACrC;YACD,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO;YACnC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,UAAU,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,EAAE,SAAS,EAAE;YACtD,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,EAAE,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,MAAM;YAC7B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,SAAS,EAAE,IAAA,2BAAoB,EAAC,IAAI,CAAC,SAAS,CAAC;YAC/C,QAAQ,EAAE,IAAA,2BAAoB,EAAC,IAAI,CAAC,QAAQ,CAAC;YAC7C,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACK,UAAU,CAChB,KAAqB,EACrB,IAAqC;QAErC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;SACnD;QACD,IAAI,IAAI,EAAE;YACR,OAAO,IAAI,CAAC,EAAE,IAAI,EAAE,uBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC;SACjD;IACH,CAAC;CACF;AArED,kDAqEC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { SpanExporter } from './SpanExporter';\nimport type { ReadableSpan } from './ReadableSpan';\nimport type { ExportResult } from '@opentelemetry/core';\nimport { ExportResultCode, hrTimeToMicroseconds } from '@opentelemetry/core';\n\n/**\n * This is implementation of {@link SpanExporter} that prints spans to the\n * console. This class can be used for diagnostic purposes.\n *\n * NOTE: This {@link SpanExporter} is intended for diagnostics use only, output rendered to the console may change at any time.\n */\n\n/* eslint-disable no-console */\nexport class ConsoleSpanExporter implements SpanExporter {\n  /**\n   * Export spans.\n   * @param spans\n   * @param resultCallback\n   */\n  export(\n    spans: ReadableSpan[],\n    resultCallback: (result: ExportResult) => void\n  ): void {\n    return this._sendSpans(spans, resultCallback);\n  }\n\n  /**\n   * Shutdown the exporter.\n   */\n  shutdown(): Promise<void> {\n    this._sendSpans([]);\n    return this.forceFlush();\n  }\n\n  /**\n   * Exports any pending spans in exporter\n   */\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  /**\n   * converts span info into more readable format\n   * @param span\n   */\n  private _exportInfo(span: ReadableSpan) {\n    return {\n      resource: {\n        attributes: span.resource.attributes,\n      },\n      instrumentationScope: span.instrumentationScope,\n      traceId: span.spanContext().traceId,\n      parentSpanContext: span.parentSpanContext,\n      traceState: span.spanContext().traceState?.serialize(),\n      name: span.name,\n      id: span.spanContext().spanId,\n      kind: span.kind,\n      timestamp: hrTimeToMicroseconds(span.startTime),\n      duration: hrTimeToMicroseconds(span.duration),\n      attributes: span.attributes,\n      status: span.status,\n      events: span.events,\n      links: span.links,\n    };\n  }\n\n  /**\n   * Showing spans in console\n   * @param spans\n   * @param done\n   */\n  private _sendSpans(\n    spans: ReadableSpan[],\n    done?: (result: ExportResult) => void\n  ): void {\n    for (const span of spans) {\n      console.dir(this._exportInfo(span), { depth: 3 });\n    }\n    if (done) {\n      return done({ code: ExportResultCode.SUCCESS });\n    }\n  }\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/InMemorySpanExporter.d.ts

@@ -0,0 +1,25 @@
+import type { SpanExporter } from './SpanExporter';
+import type { ReadableSpan } from './ReadableSpan';
+import type { ExportResult } from '@opentelemetry/core';
+/**
+ * This class can be used for testing purposes. It stores the exported spans
+ * in a list in memory that can be retrieved using the `getFinishedSpans()`
+ * method.
+ */
+export declare class InMemorySpanExporter implements SpanExporter {
+    private _finishedSpans;
+    /**
+     * Indicates if the exporter has been "shutdown."
+     * When false, exported spans will not be stored in-memory.
+     */
+    protected _stopped: boolean;
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    /**
+     * Exports any pending spans in the exporter
+     */
+    forceFlush(): Promise<void>;
+    reset(): void;
+    getFinishedSpans(): ReadableSpan[];
+}
+//# sourceMappingURL=InMemorySpanExporter.d.ts.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/InMemorySpanExporter.js

@@ -0,0 +1,49 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemorySpanExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+/**
+ * This class can be used for testing purposes. It stores the exported spans
+ * in a list in memory that can be retrieved using the `getFinishedSpans()`
+ * method.
+ */
+class InMemorySpanExporter {
+    _finishedSpans = [];
+    /**
+     * Indicates if the exporter has been "shutdown."
+     * When false, exported spans will not be stored in-memory.
+     */
+    _stopped = false;
+    export(spans, resultCallback) {
+        if (this._stopped)
+            return resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: new Error('Exporter has been stopped'),
+            });
+        this._finishedSpans.push(...spans);
+        setTimeout(() => resultCallback({ code: core_1.ExportResultCode.SUCCESS }), 0);
+    }
+    shutdown() {
+        this._stopped = true;
+        this._finishedSpans = [];
+        return this.forceFlush();
+    }
+    /**
+     * Exports any pending spans in the exporter
+     */
+    forceFlush() {
+        return Promise.resolve();
+    }
+    reset() {
+        this._finishedSpans = [];
+    }
+    getFinishedSpans() {
+        return this._finishedSpans;
+    }
+}
+exports.InMemorySpanExporter = InMemorySpanExporter;
+//# sourceMappingURL=InMemorySpanExporter.js.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/InMemorySpanExporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemorySpanExporter.js","sourceRoot":"","sources":["../../../src/export/InMemorySpanExporter.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAKH,8CAAuD;AAEvD;;;;GAIG;AACH,MAAa,oBAAoB;IACvB,cAAc,GAAmB,EAAE,CAAC;IAC5C;;;OAGG;IACO,QAAQ,GAAG,KAAK,CAAC;IAE3B,MAAM,CACJ,KAAqB,EACrB,cAA8C;QAE9C,IAAI,IAAI,CAAC,QAAQ;YACf,OAAO,cAAc,CAAC;gBACpB,IAAI,EAAE,uBAAgB,CAAC,MAAM;gBAC7B,KAAK,EAAE,IAAI,KAAK,CAAC,2BAA2B,CAAC;aAC9C,CAAC,CAAC;QACL,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;QAEnC,UAAU,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,uBAAgB,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;QACzB,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,UAAU;QACR,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,KAAK;QACH,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;IAC3B,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;CACF;AA1CD,oDA0CC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { SpanExporter } from './SpanExporter';\nimport type { ReadableSpan } from './ReadableSpan';\nimport type { ExportResult } from '@opentelemetry/core';\nimport { ExportResultCode } from '@opentelemetry/core';\n\n/**\n * This class can be used for testing purposes. It stores the exported spans\n * in a list in memory that can be retrieved using the `getFinishedSpans()`\n * method.\n */\nexport class InMemorySpanExporter implements SpanExporter {\n  private _finishedSpans: ReadableSpan[] = [];\n  /**\n   * Indicates if the exporter has been \"shutdown.\"\n   * When false, exported spans will not be stored in-memory.\n   */\n  protected _stopped = false;\n\n  export(\n    spans: ReadableSpan[],\n    resultCallback: (result: ExportResult) => void\n  ): void {\n    if (this._stopped)\n      return resultCallback({\n        code: ExportResultCode.FAILED,\n        error: new Error('Exporter has been stopped'),\n      });\n    this._finishedSpans.push(...spans);\n\n    setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);\n  }\n\n  shutdown(): Promise<void> {\n    this._stopped = true;\n    this._finishedSpans = [];\n    return this.forceFlush();\n  }\n\n  /**\n   * Exports any pending spans in the exporter\n   */\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  reset(): void {\n    this._finishedSpans = [];\n  }\n\n  getFinishedSpans(): ReadableSpan[] {\n    return this._finishedSpans;\n  }\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/NoopSpanProcessor.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '@opentelemetry/api';
+import type { ReadableSpan } from './ReadableSpan';
+import type { Span } from '../Span';
+import type { SpanProcessor } from '../SpanProcessor';
+/** No-op implementation of SpanProcessor */
+export declare class NoopSpanProcessor implements SpanProcessor {
+    onStart(_span: Span, _context: Context): void;
+    onEnd(_span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+//# sourceMappingURL=NoopSpanProcessor.d.ts.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/NoopSpanProcessor.js

@@ -0,0 +1,20 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopSpanProcessor = void 0;
+/** No-op implementation of SpanProcessor */
+class NoopSpanProcessor {
+    onStart(_span, _context) { }
+    onEnd(_span) { }
+    shutdown() {
+        return Promise.resolve();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+}
+exports.NoopSpanProcessor = NoopSpanProcessor;
+//# sourceMappingURL=NoopSpanProcessor.js.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/NoopSpanProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoopSpanProcessor.js","sourceRoot":"","sources":["../../../src/export/NoopSpanProcessor.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAOH,4CAA4C;AAC5C,MAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAW,EAAE,QAAiB,IAAS,CAAC;IAChD,KAAK,CAAC,KAAmB,IAAS,CAAC;IACnC,QAAQ;QACN,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IACD,UAAU;QACR,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;CACF;AATD,8CASC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Context } from '@opentelemetry/api';\nimport type { ReadableSpan } from './ReadableSpan';\nimport type { Span } from '../Span';\nimport type { SpanProcessor } from '../SpanProcessor';\n\n/** No-op implementation of SpanProcessor */\nexport class NoopSpanProcessor implements SpanProcessor {\n  onStart(_span: Span, _context: Context): void {}\n  onEnd(_span: ReadableSpan): void {}\n  shutdown(): Promise<void> {\n    return Promise.resolve();\n  }\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/ReadableSpan.d.ts

@@ -0,0 +1,24 @@
+import type { SpanKind, SpanStatus, Attributes, HrTime, Link, SpanContext } from '@opentelemetry/api';
+import type { Resource } from '@opentelemetry/resources';
+import type { InstrumentationScope } from '@opentelemetry/core';
+import type { TimedEvent } from '../TimedEvent';
+export interface ReadableSpan {
+    readonly name: string;
+    readonly kind: SpanKind;
+    readonly spanContext: () => SpanContext;
+    readonly parentSpanContext?: SpanContext;
+    readonly startTime: HrTime;
+    readonly endTime: HrTime;
+    readonly status: SpanStatus;
+    readonly attributes: Attributes;
+    readonly links: Link[];
+    readonly events: TimedEvent[];
+    readonly duration: HrTime;
+    readonly ended: boolean;
+    readonly resource: Resource;
+    readonly instrumentationScope: InstrumentationScope;
+    readonly droppedAttributesCount: number;
+    readonly droppedEventsCount: number;
+    readonly droppedLinksCount: number;
+}
+//# sourceMappingURL=ReadableSpan.d.ts.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/ReadableSpan.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ReadableSpan.js.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/ReadableSpan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadableSpan.js","sourceRoot":"","sources":["../../../src/export/ReadableSpan.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type {\n  SpanKind,\n  SpanStatus,\n  Attributes,\n  HrTime,\n  Link,\n  SpanContext,\n} from '@opentelemetry/api';\nimport type { Resource } from '@opentelemetry/resources';\nimport type { InstrumentationScope } from '@opentelemetry/core';\nimport type { TimedEvent } from '../TimedEvent';\n\nexport interface ReadableSpan {\n  readonly name: string;\n  readonly kind: SpanKind;\n  readonly spanContext: () => SpanContext;\n  readonly parentSpanContext?: SpanContext;\n  readonly startTime: HrTime;\n  readonly endTime: HrTime;\n  readonly status: SpanStatus;\n  readonly attributes: Attributes;\n  readonly links: Link[];\n  readonly events: TimedEvent[];\n  readonly duration: HrTime;\n  readonly ended: boolean;\n  readonly resource: Resource;\n  readonly instrumentationScope: InstrumentationScope;\n  readonly droppedAttributesCount: number;\n  readonly droppedEventsCount: number;\n  readonly droppedLinksCount: number;\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/SimpleSpanProcessor.d.ts

@@ -0,0 +1,26 @@
+import type { Context } from '@opentelemetry/api';
+import type { Span } from '../Span';
+import type { SpanProcessor } from '../SpanProcessor';
+import type { ReadableSpan } from './ReadableSpan';
+import type { SpanExporter } from './SpanExporter';
+/**
+ * An implementation of the {@link SpanProcessor} that converts the {@link Span}
+ * to {@link ReadableSpan} and passes it to the configured exporter.
+ *
+ * Only spans that are sampled are converted.
+ *
+ * NOTE: This {@link SpanProcessor} exports every ended span individually instead of batching spans together, which causes significant performance overhead with most exporters. For production use, please consider using the {@link BatchSpanProcessor} instead.
+ */
+export declare class SimpleSpanProcessor implements SpanProcessor {
+    private readonly _exporter;
+    private _shutdownOnce;
+    private _pendingExports;
+    constructor(exporter: SpanExporter);
+    forceFlush(): Promise<void>;
+    onStart(_span: Span, _parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    private _doExport;
+    shutdown(): Promise<void>;
+    private _shutdown;
+}
+//# sourceMappingURL=SimpleSpanProcessor.d.ts.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/SimpleSpanProcessor.js

@@ -0,0 +1,65 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleSpanProcessor = void 0;
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+/**
+ * An implementation of the {@link SpanProcessor} that converts the {@link Span}
+ * to {@link ReadableSpan} and passes it to the configured exporter.
+ *
+ * Only spans that are sampled are converted.
+ *
+ * NOTE: This {@link SpanProcessor} exports every ended span individually instead of batching spans together, which causes significant performance overhead with most exporters. For production use, please consider using the {@link BatchSpanProcessor} instead.
+ */
+class SimpleSpanProcessor {
+    _exporter;
+    _shutdownOnce;
+    _pendingExports;
+    constructor(exporter) {
+        this._exporter = exporter;
+        this._shutdownOnce = new core_1.BindOnceFuture(this._shutdown, this);
+        this._pendingExports = new Set();
+    }
+    async forceFlush() {
+        await Promise.all(Array.from(this._pendingExports));
+        if (this._exporter.forceFlush) {
+            await this._exporter.forceFlush();
+        }
+    }
+    onStart(_span, _parentContext) { }
+    onEnd(span) {
+        if (this._shutdownOnce.isCalled) {
+            return;
+        }
+        if ((span.spanContext().traceFlags & api_1.TraceFlags.SAMPLED) === 0) {
+            return;
+        }
+        const pendingExport = this._doExport(span).catch(err => (0, core_1.globalErrorHandler)(err));
+        // Enqueue this export to the pending list so it can be flushed by the user.
+        this._pendingExports.add(pendingExport);
+        void pendingExport.finally(() => this._pendingExports.delete(pendingExport));
+    }
+    async _doExport(span) {
+        if (span.resource.asyncAttributesPending) {
+            // Ensure resource is fully resolved before exporting.
+            await span.resource.waitForAsyncAttributes?.();
+        }
+        const result = await core_1.internal._export(this._exporter, [span]);
+        if (result.code !== core_1.ExportResultCode.SUCCESS) {
+            throw (result.error ??
+                new Error(`SimpleSpanProcessor: span export failed (status ${result})`));
+        }
+    }
+    shutdown() {
+        return this._shutdownOnce.call();
+    }
+    _shutdown() {
+        return this._exporter.shutdown();
+    }
+}
+exports.SimpleSpanProcessor = SimpleSpanProcessor;
+//# sourceMappingURL=SimpleSpanProcessor.js.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/SimpleSpanProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleSpanProcessor.js","sourceRoot":"","sources":["../../../src/export/SimpleSpanProcessor.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,4CAAgD;AAChD,8CAK6B;AAM7B;;;;;;;GAOG;AACH,MAAa,mBAAmB;IACb,SAAS,CAAe;IACjC,aAAa,CAAuB;IACpC,eAAe,CAAqB;IAE5C,YAAY,QAAsB;QAChC,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,aAAa,GAAG,IAAI,qBAAc,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAC9D,IAAI,CAAC,eAAe,GAAG,IAAI,GAAG,EAAiB,CAAC;IAClD,CAAC;IAED,KAAK,CAAC,UAAU;QACd,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;QACpD,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE;YAC7B,MAAM,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;SACnC;IACH,CAAC;IAED,OAAO,CAAC,KAAW,EAAE,cAAuB,IAAS,CAAC;IAEtD,KAAK,CAAC,IAAkB;QACtB,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE;YAC/B,OAAO;SACR;QAED,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,GAAG,gBAAU,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YAC9D,OAAO;SACR;QAED,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CACrD,IAAA,yBAAkB,EAAC,GAAG,CAAC,CACxB,CAAC;QACF,4EAA4E;QAC5E,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACxC,KAAK,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE,CAC9B,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,aAAa,CAAC,CAC3C,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,IAAkB;QACxC,IAAI,IAAI,CAAC,QAAQ,CAAC,sBAAsB,EAAE;YACxC,sDAAsD;YACtD,MAAM,IAAI,CAAC,QAAQ,CAAC,sBAAsB,EAAE,EAAE,CAAC;SAChD;QAED,MAAM,MAAM,GAAG,MAAM,eAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9D,IAAI,MAAM,CAAC,IAAI,KAAK,uBAAgB,CAAC,OAAO,EAAE;YAC5C,MAAM,CACJ,MAAM,CAAC,KAAK;gBACZ,IAAI,KAAK,CAAC,mDAAmD,MAAM,GAAG,CAAC,CACxE,CAAC;SACH;IACH,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IACnC,CAAC;IAEO,SAAS;QACf,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IACnC,CAAC;CACF;AA7DD,kDA6DC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Context } from '@opentelemetry/api';\nimport { TraceFlags } from '@opentelemetry/api';\nimport {\n  internal,\n  ExportResultCode,\n  globalErrorHandler,\n  BindOnceFuture,\n} from '@opentelemetry/core';\nimport type { Span } from '../Span';\nimport type { SpanProcessor } from '../SpanProcessor';\nimport type { ReadableSpan } from './ReadableSpan';\nimport type { SpanExporter } from './SpanExporter';\n\n/**\n * An implementation of the {@link SpanProcessor} that converts the {@link Span}\n * to {@link ReadableSpan} and passes it to the configured exporter.\n *\n * Only spans that are sampled are converted.\n *\n * NOTE: This {@link SpanProcessor} exports every ended span individually instead of batching spans together, which causes significant performance overhead with most exporters. For production use, please consider using the {@link BatchSpanProcessor} instead.\n */\nexport class SimpleSpanProcessor implements SpanProcessor {\n  private readonly _exporter: SpanExporter;\n  private _shutdownOnce: BindOnceFuture<void>;\n  private _pendingExports: Set<Promise<void>>;\n\n  constructor(exporter: SpanExporter) {\n    this._exporter = exporter;\n    this._shutdownOnce = new BindOnceFuture(this._shutdown, this);\n    this._pendingExports = new Set<Promise<void>>();\n  }\n\n  async forceFlush(): Promise<void> {\n    await Promise.all(Array.from(this._pendingExports));\n    if (this._exporter.forceFlush) {\n      await this._exporter.forceFlush();\n    }\n  }\n\n  onStart(_span: Span, _parentContext: Context): void {}\n\n  onEnd(span: ReadableSpan): void {\n    if (this._shutdownOnce.isCalled) {\n      return;\n    }\n\n    if ((span.spanContext().traceFlags & TraceFlags.SAMPLED) === 0) {\n      return;\n    }\n\n    const pendingExport = this._doExport(span).catch(err =>\n      globalErrorHandler(err)\n    );\n    // Enqueue this export to the pending list so it can be flushed by the user.\n    this._pendingExports.add(pendingExport);\n    void pendingExport.finally(() =>\n      this._pendingExports.delete(pendingExport)\n    );\n  }\n\n  private async _doExport(span: ReadableSpan): Promise<void> {\n    if (span.resource.asyncAttributesPending) {\n      // Ensure resource is fully resolved before exporting.\n      await span.resource.waitForAsyncAttributes?.();\n    }\n\n    const result = await internal._export(this._exporter, [span]);\n    if (result.code !== ExportResultCode.SUCCESS) {\n      throw (\n        result.error ??\n        new Error(`SimpleSpanProcessor: span export failed (status ${result})`)\n      );\n    }\n  }\n\n  shutdown(): Promise<void> {\n    return this._shutdownOnce.call();\n  }\n\n  private _shutdown(): Promise<void> {\n    return this._exporter.shutdown();\n  }\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/SpanExporter.d.ts

@@ -0,0 +1,21 @@
+import type { ExportResult } from '@opentelemetry/core';
+import type { ReadableSpan } from './ReadableSpan';
+/**
+ * An interface that allows different tracing services to export recorded data
+ * for sampled spans in their own format.
+ *
+ * To export data this MUST be register to the Tracer SDK using a optional
+ * config.
+ */
+export interface SpanExporter {
+    /**
+     * Called to export sampled {@link ReadableSpan}s.
+     * @param spans the list of sampled Spans to be exported.
+     */
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    /** Stops the exporter. */
+    shutdown(): Promise<void>;
+    /** Immediately export all spans */
+    forceFlush?(): Promise<void>;
+}
+//# sourceMappingURL=SpanExporter.d.ts.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/SpanExporter.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SpanExporter.js.map

~/.npm-cache/@opentelemetry/sdk-trace-base@2.6.1@@@1/build/src/export/SpanExporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpanExporter.js","sourceRoot":"","sources":["../../../src/export/SpanExporter.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { ExportResult } from '@opentelemetry/core';\nimport type { ReadableSpan } from './ReadableSpan';\n\n/**\n * An interface that allows different tracing services to export recorded data\n * for sampled spans in their own format.\n *\n * To export data this MUST be register to the Tracer SDK using a optional\n * config.\n */\nexport interface SpanExporter {\n  /**\n   * Called to export sampled {@link ReadableSpan}s.\n   * @param spans the list of sampled Spans to be exported.\n   */\n  export(\n    spans: ReadableSpan[],\n    resultCallback: (result: ExportResult) => void\n  ): void;\n\n  /** Stops the exporter. */\n  shutdown(): Promise<void>;\n\n  /** Immediately export all spans */\n  forceFlush?(): Promise<void>;\n}\n"]}