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-logs@0.214.0@@@1/build/esnext/export/BatchLogRecordProcessorBase.d.ts

@@ -0,0 +1,34 @@
+import type { BufferConfig } from '../types';
+import type { SdkLogRecord } from './SdkLogRecord';
+import type { LogRecordExporter } from './LogRecordExporter';
+import type { LogRecordProcessor } from '../LogRecordProcessor';
+export declare abstract class BatchLogRecordProcessorBase<T extends BufferConfig> implements LogRecordProcessor {
+    private readonly _maxExportBatchSize;
+    private readonly _maxQueueSize;
+    private readonly _scheduledDelayMillis;
+    private readonly _exportTimeoutMillis;
+    private readonly _exporter;
+    private _isExporting;
+    private _finishedLogRecords;
+    private _timer;
+    private _shutdownOnce;
+    constructor(exporter: LogRecordExporter, config?: T);
+    onEmit(logRecord: SdkLogRecord): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private _shutdown;
+    /** Add a LogRecord in the buffer. */
+    private _addToBuffer;
+    /**
+     * Send all LogRecords 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;
+    private _export;
+    protected abstract onShutdown(): void;
+}
+//# sourceMappingURL=BatchLogRecordProcessorBase.d.ts.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/BatchLogRecordProcessorBase.js

@@ -0,0 +1,146 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { diag } from '@opentelemetry/api';
+import { ExportResultCode, globalErrorHandler, BindOnceFuture, internal, callWithTimeout, } from '@opentelemetry/core';
+export class BatchLogRecordProcessorBase {
+    _maxExportBatchSize;
+    _maxQueueSize;
+    _scheduledDelayMillis;
+    _exportTimeoutMillis;
+    _exporter;
+    _isExporting = false;
+    _finishedLogRecords = [];
+    _timer;
+    _shutdownOnce;
+    constructor(exporter, config) {
+        this._exporter = exporter;
+        this._maxExportBatchSize = config?.maxExportBatchSize ?? 512;
+        this._maxQueueSize = config?.maxQueueSize ?? 2048;
+        this._scheduledDelayMillis = config?.scheduledDelayMillis ?? 5000;
+        this._exportTimeoutMillis = config?.exportTimeoutMillis ?? 30000;
+        this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+        if (this._maxExportBatchSize > this._maxQueueSize) {
+            diag.warn('BatchLogRecordProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize');
+            this._maxExportBatchSize = this._maxQueueSize;
+        }
+    }
+    onEmit(logRecord) {
+        if (this._shutdownOnce.isCalled) {
+            return;
+        }
+        this._addToBuffer(logRecord);
+    }
+    forceFlush() {
+        if (this._shutdownOnce.isCalled) {
+            return this._shutdownOnce.promise;
+        }
+        return this._flushAll();
+    }
+    shutdown() {
+        return this._shutdownOnce.call();
+    }
+    async _shutdown() {
+        this.onShutdown();
+        await this._flushAll();
+        await this._exporter.shutdown();
+    }
+    /** Add a LogRecord in the buffer. */
+    _addToBuffer(logRecord) {
+        if (this._finishedLogRecords.length >= this._maxQueueSize) {
+            return;
+        }
+        this._finishedLogRecords.push(logRecord);
+        this._maybeStartTimer();
+    }
+    /**
+     * Send all LogRecords 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 = [];
+            const batchCount = Math.ceil(this._finishedLogRecords.length / this._maxExportBatchSize);
+            for (let i = 0; i < batchCount; i++) {
+                promises.push(this._flushOneBatch());
+            }
+            Promise.all(promises)
+                .then(() => {
+                resolve();
+            })
+                .catch(reject);
+        });
+    }
+    _flushOneBatch() {
+        this._clearTimer();
+        if (this._finishedLogRecords.length === 0) {
+            return Promise.resolve();
+        }
+        return callWithTimeout(this._export(this._finishedLogRecords.splice(0, this._maxExportBatchSize)), this._exportTimeoutMillis);
+    }
+    _maybeStartTimer() {
+        if (this._isExporting)
+            return;
+        const flush = () => {
+            this._isExporting = true;
+            this._flushOneBatch()
+                .then(() => {
+                this._isExporting = false;
+                if (this._finishedLogRecords.length > 0) {
+                    this._clearTimer();
+                    this._maybeStartTimer();
+                }
+            })
+                .catch(e => {
+                this._isExporting = false;
+                globalErrorHandler(e);
+            });
+        };
+        // we only wait if the queue doesn't have enough elements yet
+        if (this._finishedLogRecords.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;
+        }
+    }
+    _export(logRecords) {
+        const doExport = () => internal
+            ._export(this._exporter, logRecords)
+            .then((result) => {
+            if (result.code !== ExportResultCode.SUCCESS) {
+                globalErrorHandler(result.error ??
+                    new Error(`BatchLogRecordProcessor: log record export failed (status ${result})`));
+            }
+        })
+            .catch(globalErrorHandler);
+        const pendingResources = [];
+        for (let i = 0; i < logRecords.length; i++) {
+            const resource = logRecords[i].resource;
+            if (resource.asyncAttributesPending &&
+                typeof resource.waitForAsyncAttributes === 'function') {
+                pendingResources.push(resource.waitForAsyncAttributes());
+            }
+        }
+        // Avoid scheduling a promise to make the behavior more predictable and easier to test
+        if (pendingResources.length === 0) {
+            return doExport();
+        }
+        else {
+            return Promise.all(pendingResources).then(doExport, globalErrorHandler);
+        }
+    }
+}
+//# sourceMappingURL=BatchLogRecordProcessorBase.js.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/ConsoleLogRecordExporter.d.ts

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

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/ConsoleLogRecordExporter.js

@@ -0,0 +1,61 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ExportResultCode, hrTimeToMicroseconds } from '@opentelemetry/core';
+/**
+ * This is implementation of {@link LogRecordExporter} that prints LogRecords to the
+ * console. This class can be used for diagnostic purposes.
+ *
+ * NOTE: This {@link LogRecordExporter} is intended for diagnostics use only, output rendered to the console may change at any time.
+ */
+/* eslint-disable no-console */
+export class ConsoleLogRecordExporter {
+    /**
+     * Export logs.
+     * @param logs
+     * @param resultCallback
+     */
+    export(logs, resultCallback) {
+        this._sendLogRecords(logs, resultCallback);
+    }
+    /**
+     * Shutdown the exporter.
+     */
+    shutdown() {
+        return Promise.resolve();
+    }
+    /**
+     * converts logRecord info into more readable format
+     * @param logRecord
+     */
+    _exportInfo(logRecord) {
+        return {
+            resource: {
+                attributes: logRecord.resource.attributes,
+            },
+            instrumentationScope: logRecord.instrumentationScope,
+            timestamp: hrTimeToMicroseconds(logRecord.hrTime),
+            traceId: logRecord.spanContext?.traceId,
+            spanId: logRecord.spanContext?.spanId,
+            traceFlags: logRecord.spanContext?.traceFlags,
+            severityText: logRecord.severityText,
+            severityNumber: logRecord.severityNumber,
+            eventName: logRecord.eventName,
+            body: logRecord.body,
+            attributes: logRecord.attributes,
+        };
+    }
+    /**
+     * Showing logs  in console
+     * @param logRecords
+     * @param done
+     */
+    _sendLogRecords(logRecords, done) {
+        for (const logRecord of logRecords) {
+            console.dir(this._exportInfo(logRecord), { depth: 3 });
+        }
+        done?.({ code: ExportResultCode.SUCCESS });
+    }
+}
+//# sourceMappingURL=ConsoleLogRecordExporter.js.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/ConsoleLogRecordExporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleLogRecordExporter.js","sourceRoot":"","sources":["../../../src/export/ConsoleLogRecordExporter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAK7E;;;;;GAKG;AAEH,+BAA+B;AAC/B,MAAM,OAAO,wBAAwB;IACnC;;;;OAIG;IACI,MAAM,CACX,IAAyB,EACzB,cAA8C;QAE9C,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACI,QAAQ;QACb,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACK,WAAW,CAAC,SAA4B;QAC9C,OAAO;YACL,QAAQ,EAAE;gBACR,UAAU,EAAE,SAAS,CAAC,QAAQ,CAAC,UAAU;aAC1C;YACD,oBAAoB,EAAE,SAAS,CAAC,oBAAoB;YACpD,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC,MAAM,CAAC;YACjD,OAAO,EAAE,SAAS,CAAC,WAAW,EAAE,OAAO;YACvC,MAAM,EAAE,SAAS,CAAC,WAAW,EAAE,MAAM;YACrC,UAAU,EAAE,SAAS,CAAC,WAAW,EAAE,UAAU;YAC7C,YAAY,EAAE,SAAS,CAAC,YAAY;YACpC,cAAc,EAAE,SAAS,CAAC,cAAc;YACxC,SAAS,EAAE,SAAS,CAAC,SAAS;YAC9B,IAAI,EAAE,SAAS,CAAC,IAAI;YACpB,UAAU,EAAE,SAAS,CAAC,UAAU;SACjC,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACK,eAAe,CACrB,UAA+B,EAC/B,IAAqC;QAErC,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;YAClC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;SACxD;QACD,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC;IAC7C,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { ExportResult } from '@opentelemetry/core';\nimport { ExportResultCode, hrTimeToMicroseconds } from '@opentelemetry/core';\n\nimport type { ReadableLogRecord } from './ReadableLogRecord';\nimport type { LogRecordExporter } from './LogRecordExporter';\n\n/**\n * This is implementation of {@link LogRecordExporter} that prints LogRecords to the\n * console. This class can be used for diagnostic purposes.\n *\n * NOTE: This {@link LogRecordExporter} 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 ConsoleLogRecordExporter implements LogRecordExporter {\n  /**\n   * Export logs.\n   * @param logs\n   * @param resultCallback\n   */\n  public export(\n    logs: ReadableLogRecord[],\n    resultCallback: (result: ExportResult) => void\n  ) {\n    this._sendLogRecords(logs, resultCallback);\n  }\n\n  /**\n   * Shutdown the exporter.\n   */\n  public shutdown(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  /**\n   * converts logRecord info into more readable format\n   * @param logRecord\n   */\n  private _exportInfo(logRecord: ReadableLogRecord) {\n    return {\n      resource: {\n        attributes: logRecord.resource.attributes,\n      },\n      instrumentationScope: logRecord.instrumentationScope,\n      timestamp: hrTimeToMicroseconds(logRecord.hrTime),\n      traceId: logRecord.spanContext?.traceId,\n      spanId: logRecord.spanContext?.spanId,\n      traceFlags: logRecord.spanContext?.traceFlags,\n      severityText: logRecord.severityText,\n      severityNumber: logRecord.severityNumber,\n      eventName: logRecord.eventName,\n      body: logRecord.body,\n      attributes: logRecord.attributes,\n    };\n  }\n\n  /**\n   * Showing logs  in console\n   * @param logRecords\n   * @param done\n   */\n  private _sendLogRecords(\n    logRecords: ReadableLogRecord[],\n    done?: (result: ExportResult) => void\n  ): void {\n    for (const logRecord of logRecords) {\n      console.dir(this._exportInfo(logRecord), { depth: 3 });\n    }\n    done?.({ code: ExportResultCode.SUCCESS });\n  }\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/InMemoryLogRecordExporter.d.ts

@@ -0,0 +1,21 @@
+import type { ExportResult } from '@opentelemetry/core';
+import type { ReadableLogRecord } from './ReadableLogRecord';
+import type { LogRecordExporter } from './LogRecordExporter';
+/**
+ * This class can be used for testing purposes. It stores the exported LogRecords
+ * in a list in memory that can be retrieved using the `getFinishedLogRecords()`
+ * method.
+ */
+export declare class InMemoryLogRecordExporter implements LogRecordExporter {
+    private _finishedLogRecords;
+    /**
+     * Indicates if the exporter has been "shutdown."
+     * When false, exported log records will not be stored in-memory.
+     */
+    protected _stopped: boolean;
+    export(logs: ReadableLogRecord[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    getFinishedLogRecords(): ReadableLogRecord[];
+    reset(): void;
+}
+//# sourceMappingURL=InMemoryLogRecordExporter.d.ts.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/InMemoryLogRecordExporter.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ExportResultCode } from '@opentelemetry/core';
+/**
+ * This class can be used for testing purposes. It stores the exported LogRecords
+ * in a list in memory that can be retrieved using the `getFinishedLogRecords()`
+ * method.
+ */
+export class InMemoryLogRecordExporter {
+    _finishedLogRecords = [];
+    /**
+     * Indicates if the exporter has been "shutdown."
+     * When false, exported log records will not be stored in-memory.
+     */
+    _stopped = false;
+    export(logs, resultCallback) {
+        if (this._stopped) {
+            return resultCallback({
+                code: ExportResultCode.FAILED,
+                error: new Error('Exporter has been stopped'),
+            });
+        }
+        this._finishedLogRecords.push(...logs);
+        resultCallback({ code: ExportResultCode.SUCCESS });
+    }
+    shutdown() {
+        this._stopped = true;
+        this.reset();
+        return Promise.resolve();
+    }
+    getFinishedLogRecords() {
+        return this._finishedLogRecords;
+    }
+    reset() {
+        this._finishedLogRecords = [];
+    }
+}
+//# sourceMappingURL=InMemoryLogRecordExporter.js.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/InMemoryLogRecordExporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryLogRecordExporter.js","sourceRoot":"","sources":["../../../src/export/InMemoryLogRecordExporter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAKvD;;;;GAIG;AACH,MAAM,OAAO,yBAAyB;IAC5B,mBAAmB,GAAwB,EAAE,CAAC;IAEtD;;;OAGG;IACO,QAAQ,GAAG,KAAK,CAAC;IAEpB,MAAM,CACX,IAAyB,EACzB,cAA8C;QAE9C,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,OAAO,cAAc,CAAC;gBACpB,IAAI,EAAE,gBAAgB,CAAC,MAAM;gBAC7B,KAAK,EAAE,IAAI,KAAK,CAAC,2BAA2B,CAAC;aAC9C,CAAC,CAAC;SACJ;QAED,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACvC,cAAc,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC;IACrD,CAAC;IAEM,QAAQ;QACb,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAEM,qBAAqB;QAC1B,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAEM,KAAK;QACV,IAAI,CAAC,mBAAmB,GAAG,EAAE,CAAC;IAChC,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { ExportResult } from '@opentelemetry/core';\nimport { ExportResultCode } from '@opentelemetry/core';\n\nimport type { ReadableLogRecord } from './ReadableLogRecord';\nimport type { LogRecordExporter } from './LogRecordExporter';\n\n/**\n * This class can be used for testing purposes. It stores the exported LogRecords\n * in a list in memory that can be retrieved using the `getFinishedLogRecords()`\n * method.\n */\nexport class InMemoryLogRecordExporter implements LogRecordExporter {\n  private _finishedLogRecords: ReadableLogRecord[] = [];\n\n  /**\n   * Indicates if the exporter has been \"shutdown.\"\n   * When false, exported log records will not be stored in-memory.\n   */\n  protected _stopped = false;\n\n  public export(\n    logs: ReadableLogRecord[],\n    resultCallback: (result: ExportResult) => void\n  ) {\n    if (this._stopped) {\n      return resultCallback({\n        code: ExportResultCode.FAILED,\n        error: new Error('Exporter has been stopped'),\n      });\n    }\n\n    this._finishedLogRecords.push(...logs);\n    resultCallback({ code: ExportResultCode.SUCCESS });\n  }\n\n  public shutdown(): Promise<void> {\n    this._stopped = true;\n    this.reset();\n    return Promise.resolve();\n  }\n\n  public getFinishedLogRecords(): ReadableLogRecord[] {\n    return this._finishedLogRecords;\n  }\n\n  public reset(): void {\n    this._finishedLogRecords = [];\n  }\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/LogRecordExporter.d.ts

@@ -0,0 +1,12 @@
+import type { ExportResult } from '@opentelemetry/core';
+import type { ReadableLogRecord } from './ReadableLogRecord';
+export interface LogRecordExporter {
+    /**
+     * Called to export {@link ReadableLogRecord}s.
+     * @param logs the list of sampled LogRecords to be exported.
+     */
+    export(logs: ReadableLogRecord[], resultCallback: (result: ExportResult) => void): void;
+    /** Stops the exporter. */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=LogRecordExporter.d.ts.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/LogRecordExporter.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=LogRecordExporter.js.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/LogRecordExporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogRecordExporter.js","sourceRoot":"","sources":["../../../src/export/LogRecordExporter.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';\n\nimport type { ReadableLogRecord } from './ReadableLogRecord';\n\nexport interface LogRecordExporter {\n  /**\n   * Called to export {@link ReadableLogRecord}s.\n   * @param logs the list of sampled LogRecords to be exported.\n   */\n  export(\n    logs: ReadableLogRecord[],\n    resultCallback: (result: ExportResult) => void\n  ): void;\n\n  /** Stops the exporter. */\n  shutdown(): Promise<void>;\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/NoopLogRecordProcessor.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from '@opentelemetry/api';
+import type { LogRecordProcessor } from '../LogRecordProcessor';
+import type { ReadableLogRecord } from './ReadableLogRecord';
+export declare class NoopLogRecordProcessor implements LogRecordProcessor {
+    forceFlush(): Promise<void>;
+    onEmit(_logRecord: ReadableLogRecord, _context: Context): void;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=NoopLogRecordProcessor.d.ts.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/NoopLogRecordProcessor.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export class NoopLogRecordProcessor {
+    forceFlush() {
+        return Promise.resolve();
+    }
+    onEmit(_logRecord, _context) { }
+    shutdown() {
+        return Promise.resolve();
+    }
+}
+//# sourceMappingURL=NoopLogRecordProcessor.js.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/NoopLogRecordProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoopLogRecordProcessor.js","sourceRoot":"","sources":["../../../src/export/NoopLogRecordProcessor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,OAAO,sBAAsB;IACjC,UAAU;QACR,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,MAAM,CAAC,UAA6B,EAAE,QAAiB,IAAS,CAAC;IAEjE,QAAQ;QACN,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Context } from '@opentelemetry/api';\nimport type { LogRecordProcessor } from '../LogRecordProcessor';\nimport type { ReadableLogRecord } from './ReadableLogRecord';\n\nexport class NoopLogRecordProcessor implements LogRecordProcessor {\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  onEmit(_logRecord: ReadableLogRecord, _context: Context): void {}\n\n  shutdown(): Promise<void> {\n    return Promise.resolve();\n  }\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/ReadableLogRecord.d.ts

@@ -0,0 +1,18 @@
+import type { Resource } from '@opentelemetry/resources';
+import type { HrTime, SpanContext } from '@opentelemetry/api';
+import type { InstrumentationScope } from '@opentelemetry/core';
+import type { LogBody, LogAttributes, SeverityNumber } from '@opentelemetry/api-logs';
+export interface ReadableLogRecord {
+    readonly hrTime: HrTime;
+    readonly hrTimeObserved: HrTime;
+    readonly spanContext?: SpanContext;
+    readonly severityText?: string;
+    readonly severityNumber?: SeverityNumber;
+    readonly body?: LogBody;
+    readonly eventName?: string;
+    readonly resource: Resource;
+    readonly instrumentationScope: InstrumentationScope;
+    readonly attributes: LogAttributes;
+    readonly droppedAttributesCount: number;
+}
+//# sourceMappingURL=ReadableLogRecord.d.ts.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/ReadableLogRecord.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=ReadableLogRecord.js.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/ReadableLogRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadableLogRecord.js","sourceRoot":"","sources":["../../../src/export/ReadableLogRecord.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Resource } from '@opentelemetry/resources';\nimport type { HrTime, SpanContext } from '@opentelemetry/api';\nimport type { InstrumentationScope } from '@opentelemetry/core';\nimport type {\n  LogBody,\n  LogAttributes,\n  SeverityNumber,\n} from '@opentelemetry/api-logs';\n\nexport interface ReadableLogRecord {\n  readonly hrTime: HrTime;\n  readonly hrTimeObserved: HrTime;\n  readonly spanContext?: SpanContext;\n  readonly severityText?: string;\n  readonly severityNumber?: SeverityNumber;\n  readonly body?: LogBody;\n  readonly eventName?: string;\n  readonly resource: Resource;\n  readonly instrumentationScope: InstrumentationScope;\n  readonly attributes: LogAttributes;\n  readonly droppedAttributesCount: number;\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/SdkLogRecord.d.ts

@@ -0,0 +1,64 @@
+import type { HrTime, SpanContext } from '@opentelemetry/api';
+import type { InstrumentationScope } from '@opentelemetry/core';
+import type { AnyValue, LogBody, LogAttributes, SeverityNumber } from '@opentelemetry/api-logs';
+import type { Resource } from '@opentelemetry/resources';
+/**
+ * A recording of an event. Typically, the record includes a timestamp indicating when the
+ * event happened as well as other data that describes what happened, where it happened, etc.
+ *
+ * @remarks
+ * This interface is **not intended to be implemented by users**.
+ * To produce logs, use {@link Logger#emit}. To consume logs, implement {@link LogRecordProcessor#onEmit}.
+ * SdkLogRecord instances are created and managed by the SDK.
+ */
+export interface SdkLogRecord {
+    readonly hrTime: HrTime;
+    readonly hrTimeObserved: HrTime;
+    readonly spanContext?: SpanContext;
+    readonly resource: Resource;
+    readonly instrumentationScope: InstrumentationScope;
+    readonly attributes: LogAttributes;
+    severityText?: string;
+    severityNumber?: SeverityNumber;
+    body?: LogBody;
+    eventName?: string;
+    droppedAttributesCount: number;
+    /**
+     * Sets a single attribute on the log record.
+     * @param key The attribute key.
+     * @param value The attribute value.
+     * @returns The updated SdkLogRecord.
+     */
+    setAttribute(key: string, value?: AnyValue): SdkLogRecord;
+    /**
+     * Sets multiple attributes on the log record.
+     * @param attributes The attributes to set.
+     * @returns The updated SdkLogRecord.
+     */
+    setAttributes(attributes: LogAttributes): SdkLogRecord;
+    /**
+     * Sets the body of the log record.
+     * @param body The log body.
+     * @returns The updated SdkLogRecord.
+     */
+    setBody(body: LogBody): SdkLogRecord;
+    /**
+     * Sets the event name for the log record.
+     * @param eventName The event name.
+     * @returns The updated SdkLogRecord.
+     */
+    setEventName(eventName: string): SdkLogRecord;
+    /**
+     * Sets the severity number for the log record.
+     * @param severityNumber The severity number.
+     * @returns The updated SdkLogRecord.
+     */
+    setSeverityNumber(severityNumber: SeverityNumber): SdkLogRecord;
+    /**
+     * Sets the severity text (log level) for the log record.
+     * @param severityText The severity text.
+     * @returns The updated SdkLogRecord.
+     */
+    setSeverityText(severityText: string): SdkLogRecord;
+}
+//# sourceMappingURL=SdkLogRecord.d.ts.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/SdkLogRecord.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=SdkLogRecord.js.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/SdkLogRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdkLogRecord.js","sourceRoot":"","sources":["../../../src/export/SdkLogRecord.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { HrTime, SpanContext } from '@opentelemetry/api';\nimport type { InstrumentationScope } from '@opentelemetry/core';\nimport type {\n  AnyValue,\n  LogBody,\n  LogAttributes,\n  SeverityNumber,\n} from '@opentelemetry/api-logs';\nimport type { Resource } from '@opentelemetry/resources';\n\n/**\n * A recording of an event. Typically, the record includes a timestamp indicating when the\n * event happened as well as other data that describes what happened, where it happened, etc.\n *\n * @remarks\n * This interface is **not intended to be implemented by users**.\n * To produce logs, use {@link Logger#emit}. To consume logs, implement {@link LogRecordProcessor#onEmit}.\n * SdkLogRecord instances are created and managed by the SDK.\n */\nexport interface SdkLogRecord {\n  readonly hrTime: HrTime;\n  readonly hrTimeObserved: HrTime;\n  readonly spanContext?: SpanContext;\n  readonly resource: Resource;\n  readonly instrumentationScope: InstrumentationScope;\n  readonly attributes: LogAttributes;\n  severityText?: string;\n  severityNumber?: SeverityNumber;\n  body?: LogBody;\n  eventName?: string;\n  droppedAttributesCount: number;\n\n  /**\n   * Sets a single attribute on the log record.\n   * @param key The attribute key.\n   * @param value The attribute value.\n   * @returns The updated SdkLogRecord.\n   */\n  setAttribute(key: string, value?: AnyValue): SdkLogRecord;\n\n  /**\n   * Sets multiple attributes on the log record.\n   * @param attributes The attributes to set.\n   * @returns The updated SdkLogRecord.\n   */\n  setAttributes(attributes: LogAttributes): SdkLogRecord;\n\n  /**\n   * Sets the body of the log record.\n   * @param body The log body.\n   * @returns The updated SdkLogRecord.\n   */\n  setBody(body: LogBody): SdkLogRecord;\n\n  /**\n   * Sets the event name for the log record.\n   * @param eventName The event name.\n   * @returns The updated SdkLogRecord.\n   */\n  setEventName(eventName: string): SdkLogRecord;\n\n  /**\n   * Sets the severity number for the log record.\n   * @param severityNumber The severity number.\n   * @returns The updated SdkLogRecord.\n   */\n  setSeverityNumber(severityNumber: SeverityNumber): SdkLogRecord;\n\n  /**\n   * Sets the severity text (log level) for the log record.\n   * @param severityText The severity text.\n   * @returns The updated SdkLogRecord.\n   */\n  setSeverityText(severityText: string): SdkLogRecord;\n}\n"]}

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/SimpleLogRecordProcessor.d.ts

@@ -0,0 +1,23 @@
+import type { LogRecordExporter } from './LogRecordExporter';
+import type { LogRecordProcessor } from '../LogRecordProcessor';
+import type { SdkLogRecord } from './SdkLogRecord';
+/**
+ * An implementation of the {@link LogRecordProcessor} interface that exports
+ * each {@link LogRecord} as it is emitted.
+ *
+ * NOTE: This {@link LogRecordProcessor} exports every {@link LogRecord}
+ * individually instead of batching them together, which can cause significant
+ * performance overhead with most exporters. For production use, please consider
+ * using the {@link BatchLogRecordProcessor} instead.
+ */
+export declare class SimpleLogRecordProcessor implements LogRecordProcessor {
+    private readonly _exporter;
+    private _shutdownOnce;
+    private _unresolvedExports;
+    constructor(exporter: LogRecordExporter);
+    onEmit(logRecord: SdkLogRecord): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private _shutdown;
+}
+//# sourceMappingURL=SimpleLogRecordProcessor.d.ts.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/SimpleLogRecordProcessor.js

@@ -0,0 +1,68 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BindOnceFuture, ExportResultCode, globalErrorHandler, internal, } from '@opentelemetry/core';
+/**
+ * An implementation of the {@link LogRecordProcessor} interface that exports
+ * each {@link LogRecord} as it is emitted.
+ *
+ * NOTE: This {@link LogRecordProcessor} exports every {@link LogRecord}
+ * individually instead of batching them together, which can cause significant
+ * performance overhead with most exporters. For production use, please consider
+ * using the {@link BatchLogRecordProcessor} instead.
+ */
+export class SimpleLogRecordProcessor {
+    _exporter;
+    _shutdownOnce;
+    _unresolvedExports;
+    constructor(exporter) {
+        this._exporter = exporter;
+        this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+        this._unresolvedExports = new Set();
+    }
+    onEmit(logRecord) {
+        if (this._shutdownOnce.isCalled) {
+            return;
+        }
+        const doExport = () => internal
+            ._export(this._exporter, [logRecord])
+            .then((result) => {
+            if (result.code !== ExportResultCode.SUCCESS) {
+                globalErrorHandler(result.error ??
+                    new Error(`SimpleLogRecordProcessor: log record export failed (status ${result})`));
+            }
+        })
+            .catch(globalErrorHandler);
+        // Avoid scheduling a promise to make the behavior more predictable and easier to test
+        if (logRecord.resource.asyncAttributesPending) {
+            const exportPromise = logRecord.resource
+                .waitForAsyncAttributes?.()
+                .then(() => {
+                // Using TS Non-null assertion operator because exportPromise could not be null in here
+                // if waitForAsyncAttributes is not present this code will never be reached
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                this._unresolvedExports.delete(exportPromise);
+                return doExport();
+            }, globalErrorHandler);
+            // store the unresolved exports
+            if (exportPromise != null) {
+                this._unresolvedExports.add(exportPromise);
+            }
+        }
+        else {
+            void doExport();
+        }
+    }
+    async forceFlush() {
+        // await unresolved resources before resolving
+        await Promise.all(Array.from(this._unresolvedExports));
+    }
+    shutdown() {
+        return this._shutdownOnce.call();
+    }
+    _shutdown() {
+        return this._exporter.shutdown();
+    }
+}
+//# sourceMappingURL=SimpleLogRecordProcessor.js.map

~/.npm-cache/@opentelemetry/sdk-logs@0.214.0@@@1/build/esnext/export/SimpleLogRecordProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleLogRecordProcessor.js","sourceRoot":"","sources":["../../../src/export/SimpleLogRecordProcessor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,QAAQ,GACT,MAAM,qBAAqB,CAAC;AAK7B;;;;;;;;GAQG;AACH,MAAM,OAAO,wBAAwB;IAClB,SAAS,CAAoB;IACtC,aAAa,CAAuB;IACpC,kBAAkB,CAAqB;IAE/C,YAAY,QAA2B;QACrC,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,aAAa,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAC9D,IAAI,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAAiB,CAAC;IACrD,CAAC;IAEM,MAAM,CAAC,SAAuB;QACnC,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE;YAC/B,OAAO;SACR;QAED,MAAM,QAAQ,GAAG,GAAG,EAAE,CACpB,QAAQ;aACL,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,SAAS,CAAC,CAAC;aACpC,IAAI,CAAC,CAAC,MAAoB,EAAE,EAAE;YAC7B,IAAI,MAAM,CAAC,IAAI,KAAK,gBAAgB,CAAC,OAAO,EAAE;gBAC5C,kBAAkB,CAChB,MAAM,CAAC,KAAK;oBACV,IAAI,KAAK,CACP,8DAA8D,MAAM,GAAG,CACxE,CACJ,CAAC;aACH;QACH,CAAC,CAAC;aACD,KAAK,CAAC,kBAAkB,CAAC,CAAC;QAE/B,sFAAsF;QACtF,IAAI,SAAS,CAAC,QAAQ,CAAC,sBAAsB,EAAE;YAC7C,MAAM,aAAa,GAAG,SAAS,CAAC,QAAQ;iBACrC,sBAAsB,EAAE,EAAE;iBAC1B,IAAI,CAAC,GAAG,EAAE;gBACT,uFAAuF;gBACvF,2EAA2E;gBAC3E,oEAAoE;gBACpE,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,aAAc,CAAC,CAAC;gBAC/C,OAAO,QAAQ,EAAE,CAAC;YACpB,CAAC,EAAE,kBAAkB,CAAC,CAAC;YAEzB,+BAA+B;YAC/B,IAAI,aAAa,IAAI,IAAI,EAAE;gBACzB,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;aAC5C;SACF;aAAM;YACL,KAAK,QAAQ,EAAE,CAAC;SACjB;IACH,CAAC;IAEM,KAAK,CAAC,UAAU;QACrB,8CAA8C;QAC9C,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC;IACzD,CAAC;IAEM,QAAQ;QACb,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IACnC,CAAC;IAEO,SAAS;QACf,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IACnC,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { ExportResult } from '@opentelemetry/core';\nimport {\n  BindOnceFuture,\n  ExportResultCode,\n  globalErrorHandler,\n  internal,\n} from '@opentelemetry/core';\nimport type { LogRecordExporter } from './LogRecordExporter';\nimport type { LogRecordProcessor } from '../LogRecordProcessor';\nimport type { SdkLogRecord } from './SdkLogRecord';\n\n/**\n * An implementation of the {@link LogRecordProcessor} interface that exports\n * each {@link LogRecord} as it is emitted.\n *\n * NOTE: This {@link LogRecordProcessor} exports every {@link LogRecord}\n * individually instead of batching them together, which can cause significant\n * performance overhead with most exporters. For production use, please consider\n * using the {@link BatchLogRecordProcessor} instead.\n */\nexport class SimpleLogRecordProcessor implements LogRecordProcessor {\n  private readonly _exporter: LogRecordExporter;\n  private _shutdownOnce: BindOnceFuture<void>;\n  private _unresolvedExports: Set<Promise<void>>;\n\n  constructor(exporter: LogRecordExporter) {\n    this._exporter = exporter;\n    this._shutdownOnce = new BindOnceFuture(this._shutdown, this);\n    this._unresolvedExports = new Set<Promise<void>>();\n  }\n\n  public onEmit(logRecord: SdkLogRecord): void {\n    if (this._shutdownOnce.isCalled) {\n      return;\n    }\n\n    const doExport = () =>\n      internal\n        ._export(this._exporter, [logRecord])\n        .then((result: ExportResult) => {\n          if (result.code !== ExportResultCode.SUCCESS) {\n            globalErrorHandler(\n              result.error ??\n                new Error(\n                  `SimpleLogRecordProcessor: log record export failed (status ${result})`\n                )\n            );\n          }\n        })\n        .catch(globalErrorHandler);\n\n    // Avoid scheduling a promise to make the behavior more predictable and easier to test\n    if (logRecord.resource.asyncAttributesPending) {\n      const exportPromise = logRecord.resource\n        .waitForAsyncAttributes?.()\n        .then(() => {\n          // Using TS Non-null assertion operator because exportPromise could not be null in here\n          // if waitForAsyncAttributes is not present this code will never be reached\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          this._unresolvedExports.delete(exportPromise!);\n          return doExport();\n        }, globalErrorHandler);\n\n      // store the unresolved exports\n      if (exportPromise != null) {\n        this._unresolvedExports.add(exportPromise);\n      }\n    } else {\n      void doExport();\n    }\n  }\n\n  public async forceFlush(): Promise<void> {\n    // await unresolved resources before resolving\n    await Promise.all(Array.from(this._unresolvedExports));\n  }\n\n  public shutdown(): Promise<void> {\n    return this._shutdownOnce.call();\n  }\n\n  private _shutdown(): Promise<void> {\n    return this._exporter.shutdown();\n  }\n}\n"]}