init

node_modules/@opentelemetry/sdk-logs/build/src/LogRecordImpl.js

@@ -0,0 +1,193 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogRecordImpl = void 0;
+const api = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+class LogRecordImpl {
+    hrTime;
+    hrTimeObserved;
+    spanContext;
+    resource;
+    instrumentationScope;
+    attributes = {};
+    _severityText;
+    _severityNumber;
+    _body;
+    _eventName;
+    totalAttributesCount = 0;
+    _isReadonly = false;
+    _logRecordLimits;
+    set severityText(severityText) {
+        if (this._isLogRecordReadonly()) {
+            return;
+        }
+        this._severityText = severityText;
+    }
+    get severityText() {
+        return this._severityText;
+    }
+    set severityNumber(severityNumber) {
+        if (this._isLogRecordReadonly()) {
+            return;
+        }
+        this._severityNumber = severityNumber;
+    }
+    get severityNumber() {
+        return this._severityNumber;
+    }
+    set body(body) {
+        if (this._isLogRecordReadonly()) {
+            return;
+        }
+        this._body = body;
+    }
+    get body() {
+        return this._body;
+    }
+    get eventName() {
+        return this._eventName;
+    }
+    set eventName(eventName) {
+        if (this._isLogRecordReadonly()) {
+            return;
+        }
+        this._eventName = eventName;
+    }
+    get droppedAttributesCount() {
+        return this.totalAttributesCount - Object.keys(this.attributes).length;
+    }
+    constructor(_sharedState, instrumentationScope, logRecord) {
+        const { timestamp, observedTimestamp, eventName, severityNumber, severityText, body, attributes = {}, context, } = logRecord;
+        const now = Date.now();
+        this.hrTime = (0, core_1.timeInputToHrTime)(timestamp ?? now);
+        this.hrTimeObserved = (0, core_1.timeInputToHrTime)(observedTimestamp ?? now);
+        if (context) {
+            const spanContext = api.trace.getSpanContext(context);
+            if (spanContext && api.isSpanContextValid(spanContext)) {
+                this.spanContext = spanContext;
+            }
+        }
+        this.severityNumber = severityNumber;
+        this.severityText = severityText;
+        this.body = body;
+        this.resource = _sharedState.resource;
+        this.instrumentationScope = instrumentationScope;
+        this._logRecordLimits = _sharedState.logRecordLimits;
+        this._eventName = eventName;
+        this.setAttributes(attributes);
+    }
+    setAttribute(key, value) {
+        if (this._isLogRecordReadonly()) {
+            return this;
+        }
+        if (value === null) {
+            return this;
+        }
+        if (key.length === 0) {
+            api.diag.warn(`Invalid attribute key: ${key}`);
+            return this;
+        }
+        if (!(0, core_1.isAttributeValue)(value) &&
+            !(typeof value === 'object' &&
+                !Array.isArray(value) &&
+                Object.keys(value).length > 0)) {
+            api.diag.warn(`Invalid attribute value set for key: ${key}`);
+            return this;
+        }
+        this.totalAttributesCount += 1;
+        if (Object.keys(this.attributes).length >=
+            this._logRecordLimits.attributeCountLimit &&
+            !Object.prototype.hasOwnProperty.call(this.attributes, key)) {
+            // This logic is to create drop message at most once per LogRecord to prevent excessive logging.
+            if (this.droppedAttributesCount === 1) {
+                api.diag.warn('Dropping extra attributes.');
+            }
+            return this;
+        }
+        if ((0, core_1.isAttributeValue)(value)) {
+            this.attributes[key] = this._truncateToSize(value);
+        }
+        else {
+            this.attributes[key] = value;
+        }
+        return this;
+    }
+    setAttributes(attributes) {
+        for (const [k, v] of Object.entries(attributes)) {
+            this.setAttribute(k, v);
+        }
+        return this;
+    }
+    setBody(body) {
+        this.body = body;
+        return this;
+    }
+    setEventName(eventName) {
+        this.eventName = eventName;
+        return this;
+    }
+    setSeverityNumber(severityNumber) {
+        this.severityNumber = severityNumber;
+        return this;
+    }
+    setSeverityText(severityText) {
+        this.severityText = severityText;
+        return this;
+    }
+    /**
+     * @internal
+     * A LogRecordProcessor may freely modify logRecord for the duration of the OnEmit call.
+     * If logRecord is needed after OnEmit returns (i.e. for asynchronous processing) only reads are permitted.
+     */
+    _makeReadonly() {
+        this._isReadonly = true;
+    }
+    _truncateToSize(value) {
+        const limit = this._logRecordLimits.attributeValueLengthLimit;
+        // Check limit
+        if (limit <= 0) {
+            // Negative values are invalid, so do not truncate
+            api.diag.warn(`Attribute value limit must be positive, got ${limit}`);
+            return value;
+        }
+        // String
+        if (typeof value === 'string') {
+            return this._truncateToLimitUtil(value, limit);
+        }
+        // Array of strings
+        if (Array.isArray(value)) {
+            return value.map(val => typeof val === 'string' ? this._truncateToLimitUtil(val, limit) : val);
+        }
+        // Other types, no need to apply value length limit
+        return value;
+    }
+    _truncateToLimitUtil(value, limit) {
+        if (value.length <= limit) {
+            return value;
+        }
+        return value.substring(0, limit);
+    }
+    _isLogRecordReadonly() {
+        if (this._isReadonly) {
+            api.diag.warn('Can not execute the operation on emitted log record');
+        }
+        return this._isReadonly;
+    }
+}
+exports.LogRecordImpl = LogRecordImpl;
+//# sourceMappingURL=LogRecordImpl.js.map

node_modules/@opentelemetry/sdk-logs/build/src/Logger.js

@@ -0,0 +1,52 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const api_1 = require("@opentelemetry/api");
+const LogRecordImpl_1 = require("./LogRecordImpl");
+class Logger {
+    instrumentationScope;
+    _sharedState;
+    constructor(instrumentationScope, _sharedState) {
+        this.instrumentationScope = instrumentationScope;
+        this._sharedState = _sharedState;
+    }
+    emit(logRecord) {
+        const currentContext = logRecord.context || api_1.context.active();
+        /**
+         * If a Logger was obtained with include_trace_context=true,
+         * the LogRecords it emits MUST automatically include the Trace Context from the active Context,
+         * if Context has not been explicitly set.
+         */
+        const logRecordInstance = new LogRecordImpl_1.LogRecordImpl(this._sharedState, this.instrumentationScope, {
+            context: currentContext,
+            ...logRecord,
+        });
+        /**
+         * the explicitly passed Context,
+         * the current Context, or an empty Context if the Logger was obtained with include_trace_context=false
+         */
+        this._sharedState.activeProcessor.onEmit(logRecordInstance, currentContext);
+        /**
+         * A LogRecordProcessor may freely modify logRecord for the duration of the OnEmit call.
+         * If logRecord is needed after OnEmit returns (i.e. for asynchronous processing) only reads are permitted.
+         */
+        logRecordInstance._makeReadonly();
+    }
+}
+exports.Logger = Logger;
+//# sourceMappingURL=Logger.js.map

node_modules/@opentelemetry/sdk-logs/build/src/LoggerProvider.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerProvider = exports.DEFAULT_LOGGER_NAME = void 0;
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const resources_1 = require("@opentelemetry/resources");
+const core_1 = require("@opentelemetry/core");
+const Logger_1 = require("./Logger");
+const config_1 = require("./config");
+const LoggerProviderSharedState_1 = require("./internal/LoggerProviderSharedState");
+exports.DEFAULT_LOGGER_NAME = 'unknown';
+class LoggerProvider {
+    _shutdownOnce;
+    _sharedState;
+    constructor(config = {}) {
+        const mergedConfig = (0, core_1.merge)({}, (0, config_1.loadDefaultConfig)(), config);
+        const resource = config.resource ?? (0, resources_1.defaultResource)();
+        this._sharedState = new LoggerProviderSharedState_1.LoggerProviderSharedState(resource, mergedConfig.forceFlushTimeoutMillis, (0, config_1.reconfigureLimits)(mergedConfig.logRecordLimits), config?.processors ?? []);
+        this._shutdownOnce = new core_1.BindOnceFuture(this._shutdown, this);
+    }
+    /**
+     * Get a logger with the configuration of the LoggerProvider.
+     */
+    getLogger(name, version, options) {
+        if (this._shutdownOnce.isCalled) {
+            api_1.diag.warn('A shutdown LoggerProvider cannot provide a Logger');
+            return api_logs_1.NOOP_LOGGER;
+        }
+        if (!name) {
+            api_1.diag.warn('Logger requested without instrumentation scope name.');
+        }
+        const loggerName = name || exports.DEFAULT_LOGGER_NAME;
+        const key = `${loggerName}@${version || ''}:${options?.schemaUrl || ''}`;
+        if (!this._sharedState.loggers.has(key)) {
+            this._sharedState.loggers.set(key, new Logger_1.Logger({ name: loggerName, version, schemaUrl: options?.schemaUrl }, this._sharedState));
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this._sharedState.loggers.get(key);
+    }
+    /**
+     * Notifies all registered LogRecordProcessor to flush any buffered data.
+     *
+     * Returns a promise which is resolved when all flushes are complete.
+     */
+    forceFlush() {
+        // do not flush after shutdown
+        if (this._shutdownOnce.isCalled) {
+            api_1.diag.warn('invalid attempt to force flush after LoggerProvider shutdown');
+            return this._shutdownOnce.promise;
+        }
+        return this._sharedState.activeProcessor.forceFlush();
+    }
+    /**
+     * Flush all buffered data and shut down the LoggerProvider and all registered
+     * LogRecordProcessor.
+     *
+     * Returns a promise which is resolved when all flushes are complete.
+     */
+    shutdown() {
+        if (this._shutdownOnce.isCalled) {
+            api_1.diag.warn('shutdown may only be called once per LoggerProvider');
+            return this._shutdownOnce.promise;
+        }
+        return this._shutdownOnce.call();
+    }
+    _shutdown() {
+        return this._sharedState.activeProcessor.shutdown();
+    }
+}
+exports.LoggerProvider = LoggerProvider;
+//# sourceMappingURL=LoggerProvider.js.map

node_modules/@opentelemetry/sdk-logs/build/src/MultiLogRecordProcessor.js

@@ -0,0 +1,43 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiLogRecordProcessor = void 0;
+const core_1 = require("@opentelemetry/core");
+/**
+ * Implementation of the {@link LogRecordProcessor} that simply forwards all
+ * received events to a list of {@link LogRecordProcessor}s.
+ */
+class MultiLogRecordProcessor {
+    processors;
+    forceFlushTimeoutMillis;
+    constructor(processors, forceFlushTimeoutMillis) {
+        this.processors = processors;
+        this.forceFlushTimeoutMillis = forceFlushTimeoutMillis;
+    }
+    async forceFlush() {
+        const timeout = this.forceFlushTimeoutMillis;
+        await Promise.all(this.processors.map(processor => (0, core_1.callWithTimeout)(processor.forceFlush(), timeout)));
+    }
+    onEmit(logRecord, context) {
+        this.processors.forEach(processors => processors.onEmit(logRecord, context));
+    }
+    async shutdown() {
+        await Promise.all(this.processors.map(processor => processor.shutdown()));
+    }
+}
+exports.MultiLogRecordProcessor = MultiLogRecordProcessor;
+//# sourceMappingURL=MultiLogRecordProcessor.js.map

node_modules/@opentelemetry/sdk-logs/build/src/config.js

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconfigureLimits = exports.loadDefaultConfig = void 0;
+const core_1 = require("@opentelemetry/core");
+function loadDefaultConfig() {
+    return {
+        forceFlushTimeoutMillis: 30000,
+        logRecordLimits: {
+            attributeValueLengthLimit: (0, core_1.getNumberFromEnv)('OTEL_LOGRECORD_ATTRIBUTE_VALUE_LENGTH_LIMIT') ??
+                Infinity,
+            attributeCountLimit: (0, core_1.getNumberFromEnv)('OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT') ?? 128,
+        },
+        includeTraceContext: true,
+    };
+}
+exports.loadDefaultConfig = loadDefaultConfig;
+/**
+ * When general limits are provided and model specific limits are not,
+ * configures the model specific limits by using the values from the general ones.
+ * @param logRecordLimits User provided limits configuration
+ */
+function reconfigureLimits(logRecordLimits) {
+    return {
+        /**
+         * Reassign log record attribute count limit to use first non null value defined by user or use default value
+         */
+        attributeCountLimit: logRecordLimits.attributeCountLimit ??
+            (0, core_1.getNumberFromEnv)('OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT') ??
+            (0, core_1.getNumberFromEnv)('OTEL_ATTRIBUTE_COUNT_LIMIT') ??
+            128,
+        /**
+         * Reassign log record attribute value length limit to use first non null value defined by user or use default value
+         */
+        attributeValueLengthLimit: logRecordLimits.attributeValueLengthLimit ??
+            (0, core_1.getNumberFromEnv)('OTEL_LOGRECORD_ATTRIBUTE_VALUE_LENGTH_LIMIT') ??
+            (0, core_1.getNumberFromEnv)('OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT') ??
+            Infinity,
+    };
+}
+exports.reconfigureLimits = reconfigureLimits;
+//# sourceMappingURL=config.js.map

node_modules/@opentelemetry/sdk-logs/build/src/export/BatchLogRecordProcessorBase.js

@@ -0,0 +1,172 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchLogRecordProcessorBase = void 0;
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+class BatchLogRecordProcessorBase {
+    _exporter;
+    _maxExportBatchSize;
+    _maxQueueSize;
+    _scheduledDelayMillis;
+    _exportTimeoutMillis;
+    _isExporting = false;
+    _finishedLogRecords = [];
+    _timer;
+    _shutdownOnce;
+    constructor(_exporter, config) {
+        this._exporter = _exporter;
+        this._maxExportBatchSize =
+            config?.maxExportBatchSize ??
+                (0, core_1.getNumberFromEnv)('OTEL_BLRP_MAX_EXPORT_BATCH_SIZE') ??
+                512;
+        this._maxQueueSize =
+            config?.maxQueueSize ??
+                (0, core_1.getNumberFromEnv)('OTEL_BLRP_MAX_QUEUE_SIZE') ??
+                2048;
+        this._scheduledDelayMillis =
+            config?.scheduledDelayMillis ??
+                (0, core_1.getNumberFromEnv)('OTEL_BLRP_SCHEDULE_DELAY') ??
+                5000;
+        this._exportTimeoutMillis =
+            config?.exportTimeoutMillis ??
+                (0, core_1.getNumberFromEnv)('OTEL_BLRP_EXPORT_TIMEOUT') ??
+                30000;
+        this._shutdownOnce = new core_1.BindOnceFuture(this._shutdown, this);
+        if (this._maxExportBatchSize > this._maxQueueSize) {
+            api_1.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 new Promise((resolve, reject) => {
+            (0, core_1.callWithTimeout)(this._export(this._finishedLogRecords.splice(0, this._maxExportBatchSize)), this._exportTimeoutMillis)
+                .then(() => resolve())
+                .catch(reject);
+        });
+    }
+    _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;
+                (0, core_1.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 = () => core_1.internal
+            ._export(this._exporter, logRecords)
+            .then((result) => {
+            if (result.code !== core_1.ExportResultCode.SUCCESS) {
+                (0, core_1.globalErrorHandler)(result.error ??
+                    new Error(`BatchLogRecordProcessor: log record export failed (status ${result})`));
+            }
+        })
+            .catch(core_1.globalErrorHandler);
+        const pendingResources = logRecords
+            .map(logRecord => logRecord.resource)
+            .filter(resource => resource.asyncAttributesPending);
+        // 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.map(resource => resource.waitForAsyncAttributes?.())).then(doExport, core_1.globalErrorHandler);
+        }
+    }
+}
+exports.BatchLogRecordProcessorBase = BatchLogRecordProcessorBase;
+//# sourceMappingURL=BatchLogRecordProcessorBase.js.map

node_modules/@opentelemetry/sdk-logs/build/src/export/ConsoleLogRecordExporter.js

@@ -0,0 +1,75 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogRecordExporter = void 0;
+const core_1 = require("@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 */
+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: (0, core_1.hrTimeToMicroseconds)(logRecord.hrTime),
+            traceId: logRecord.spanContext?.traceId,
+            spanId: logRecord.spanContext?.spanId,
+            traceFlags: logRecord.spanContext?.traceFlags,
+            severityText: logRecord.severityText,
+            severityNumber: logRecord.severityNumber,
+            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: core_1.ExportResultCode.SUCCESS });
+    }
+}
+exports.ConsoleLogRecordExporter = ConsoleLogRecordExporter;
+//# sourceMappingURL=ConsoleLogRecordExporter.js.map

node_modules/@opentelemetry/sdk-logs/build/src/export/InMemoryLogRecordExporter.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryLogRecordExporter = void 0;
+const core_1 = require("@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.
+ */
+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: core_1.ExportResultCode.FAILED,
+                error: new Error('Exporter has been stopped'),
+            });
+        }
+        this._finishedLogRecords.push(...logs);
+        resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+    }
+    shutdown() {
+        this._stopped = true;
+        this.reset();
+        return Promise.resolve();
+    }
+    getFinishedLogRecords() {
+        return this._finishedLogRecords;
+    }
+    reset() {
+        this._finishedLogRecords = [];
+    }
+}
+exports.InMemoryLogRecordExporter = InMemoryLogRecordExporter;
+//# sourceMappingURL=InMemoryLogRecordExporter.js.map

node_modules/@opentelemetry/sdk-logs/build/src/export/NoopLogRecordProcessor.js

@@ -0,0 +1,29 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopLogRecordProcessor = void 0;
+class NoopLogRecordProcessor {
+    forceFlush() {
+        return Promise.resolve();
+    }
+    onEmit(_logRecord, _context) { }
+    shutdown() {
+        return Promise.resolve();
+    }
+}
+exports.NoopLogRecordProcessor = NoopLogRecordProcessor;
+//# sourceMappingURL=NoopLogRecordProcessor.js.map

node_modules/@opentelemetry/sdk-logs/build/src/export/SimpleLogRecordProcessor.js

@@ -0,0 +1,83 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleLogRecordProcessor = void 0;
+const core_1 = require("@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.
+ */
+class SimpleLogRecordProcessor {
+    _exporter;
+    _shutdownOnce;
+    _unresolvedExports;
+    constructor(_exporter) {
+        this._exporter = _exporter;
+        this._shutdownOnce = new core_1.BindOnceFuture(this._shutdown, this);
+        this._unresolvedExports = new Set();
+    }
+    onEmit(logRecord) {
+        if (this._shutdownOnce.isCalled) {
+            return;
+        }
+        const doExport = () => core_1.internal
+            ._export(this._exporter, [logRecord])
+            .then((result) => {
+            if (result.code !== core_1.ExportResultCode.SUCCESS) {
+                (0, core_1.globalErrorHandler)(result.error ??
+                    new Error(`SimpleLogRecordProcessor: log record export failed (status ${result})`));
+            }
+        })
+            .catch(core_1.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();
+            }, core_1.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();
+    }
+}
+exports.SimpleLogRecordProcessor = SimpleLogRecordProcessor;
+//# sourceMappingURL=SimpleLogRecordProcessor.js.map

node_modules/@opentelemetry/sdk-logs/build/src/index.js

@@ -0,0 +1,29 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchLogRecordProcessor = exports.InMemoryLogRecordExporter = exports.SimpleLogRecordProcessor = exports.ConsoleLogRecordExporter = exports.LoggerProvider = void 0;
+var LoggerProvider_1 = require("./LoggerProvider");
+Object.defineProperty(exports, "LoggerProvider", { enumerable: true, get: function () { return LoggerProvider_1.LoggerProvider; } });
+var ConsoleLogRecordExporter_1 = require("./export/ConsoleLogRecordExporter");
+Object.defineProperty(exports, "ConsoleLogRecordExporter", { enumerable: true, get: function () { return ConsoleLogRecordExporter_1.ConsoleLogRecordExporter; } });
+var SimpleLogRecordProcessor_1 = require("./export/SimpleLogRecordProcessor");
+Object.defineProperty(exports, "SimpleLogRecordProcessor", { enumerable: true, get: function () { return SimpleLogRecordProcessor_1.SimpleLogRecordProcessor; } });
+var InMemoryLogRecordExporter_1 = require("./export/InMemoryLogRecordExporter");
+Object.defineProperty(exports, "InMemoryLogRecordExporter", { enumerable: true, get: function () { return InMemoryLogRecordExporter_1.InMemoryLogRecordExporter; } });
+var platform_1 = require("./platform");
+Object.defineProperty(exports, "BatchLogRecordProcessor", { enumerable: true, get: function () { return platform_1.BatchLogRecordProcessor; } });
+//# sourceMappingURL=index.js.map

node_modules/@opentelemetry/sdk-logs/build/src/internal/LoggerProviderSharedState.js

@@ -0,0 +1,44 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerProviderSharedState = void 0;
+const NoopLogRecordProcessor_1 = require("../export/NoopLogRecordProcessor");
+const MultiLogRecordProcessor_1 = require("../MultiLogRecordProcessor");
+class LoggerProviderSharedState {
+    resource;
+    forceFlushTimeoutMillis;
+    logRecordLimits;
+    processors;
+    loggers = new Map();
+    activeProcessor;
+    registeredLogRecordProcessors = [];
+    constructor(resource, forceFlushTimeoutMillis, logRecordLimits, processors) {
+        this.resource = resource;
+        this.forceFlushTimeoutMillis = forceFlushTimeoutMillis;
+        this.logRecordLimits = logRecordLimits;
+        this.processors = processors;
+        if (processors.length > 0) {
+            this.registeredLogRecordProcessors = processors;
+            this.activeProcessor = new MultiLogRecordProcessor_1.MultiLogRecordProcessor(this.registeredLogRecordProcessors, this.forceFlushTimeoutMillis);
+        }
+        else {
+            this.activeProcessor = new NoopLogRecordProcessor_1.NoopLogRecordProcessor();
+        }
+    }
+}
+exports.LoggerProviderSharedState = LoggerProviderSharedState;
+//# sourceMappingURL=LoggerProviderSharedState.js.map

node_modules/@opentelemetry/sdk-logs/build/src/platform/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchLogRecordProcessor = void 0;
+var node_1 = require("./node");
+Object.defineProperty(exports, "BatchLogRecordProcessor", { enumerable: true, get: function () { return node_1.BatchLogRecordProcessor; } });
+//# sourceMappingURL=index.js.map

node_modules/@opentelemetry/sdk-logs/build/src/platform/node/export/BatchLogRecordProcessor.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchLogRecordProcessor = void 0;
+const BatchLogRecordProcessorBase_1 = require("../../../export/BatchLogRecordProcessorBase");
+class BatchLogRecordProcessor extends BatchLogRecordProcessorBase_1.BatchLogRecordProcessorBase {
+    onShutdown() { }
+}
+exports.BatchLogRecordProcessor = BatchLogRecordProcessor;
+//# sourceMappingURL=BatchLogRecordProcessor.js.map

node_modules/@opentelemetry/sdk-logs/build/src/platform/node/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchLogRecordProcessor = void 0;
+var BatchLogRecordProcessor_1 = require("./export/BatchLogRecordProcessor");
+Object.defineProperty(exports, "BatchLogRecordProcessor", { enumerable: true, get: function () { return BatchLogRecordProcessor_1.BatchLogRecordProcessor; } });
+//# sourceMappingURL=index.js.map