decocms 2.327.3 → 2.327.5

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js

@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+class BoundedQueueExportPromiseHandler {
+    _concurrencyLimit;
+    _sendingPromises = [];
+    /**
+     * @param concurrencyLimit maximum promises allowed in a queue at the same time.
+     */
+    constructor(concurrencyLimit) {
+        this._concurrencyLimit = concurrencyLimit;
+    }
+    pushPromise(promise) {
+        if (this.hasReachedLimit()) {
+            throw new Error('Concurrency Limit reached');
+        }
+        this._sendingPromises.push(promise);
+        const popPromise = () => {
+            const index = this._sendingPromises.indexOf(promise);
+            void this._sendingPromises.splice(index, 1);
+        };
+        promise.then(popPromise, popPromise);
+    }
+    hasReachedLimit() {
+        return this._sendingPromises.length >= this._concurrencyLimit;
+    }
+    async awaitAll() {
+        await Promise.all(this._sendingPromises);
+    }
+}
+/**
+ * Promise queue for keeping track of export promises. Finished promises will be auto-dequeued.
+ * Allows for awaiting all promises in the queue.
+ */
+export function createBoundedQueueExportPromiseHandler(options) {
+    return new BoundedQueueExportPromiseHandler(options.concurrencyLimit);
+}
+//# sourceMappingURL=bounded-queue-export-promise-handler.js.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-queue-export-promise-handler.js","sourceRoot":"","sources":["../../src/bounded-queue-export-promise-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH,MAAM,gCAAgC;IACnB,iBAAiB,CAAS;IACnC,gBAAgB,GAAuB,EAAE,CAAC;IAElD;;OAEG;IACH,YAAY,gBAAwB;QAClC,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;IAC5C,CAAC;IAEM,WAAW,CAAC,OAAsB;QACvC,IAAI,IAAI,CAAC,eAAe,EAAE,EAAE;YAC1B,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;SAC9C;QAED,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpC,MAAM,UAAU,GAAG,GAAG,EAAE;YACtB,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YACrD,KAAK,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC9C,CAAC,CAAC;QACF,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IACvC,CAAC;IAEM,eAAe;QACpB,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,IAAI,IAAI,CAAC,iBAAiB,CAAC;IAChE,CAAC;IAEM,KAAK,CAAC,QAAQ;QACnB,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC3C,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,UAAU,sCAAsC,CAAC,OAEtD;IACC,OAAO,IAAI,gCAAgC,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;AACxE,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport interface IExportPromiseHandler {\n  pushPromise(promise: Promise<void>): void;\n  hasReachedLimit(): boolean;\n  awaitAll(): Promise<void>;\n}\n\nclass BoundedQueueExportPromiseHandler implements IExportPromiseHandler {\n  private readonly _concurrencyLimit: number;\n  private _sendingPromises: Promise<unknown>[] = [];\n\n  /**\n   * @param concurrencyLimit maximum promises allowed in a queue at the same time.\n   */\n  constructor(concurrencyLimit: number) {\n    this._concurrencyLimit = concurrencyLimit;\n  }\n\n  public pushPromise(promise: Promise<void>): void {\n    if (this.hasReachedLimit()) {\n      throw new Error('Concurrency Limit reached');\n    }\n\n    this._sendingPromises.push(promise);\n    const popPromise = () => {\n      const index = this._sendingPromises.indexOf(promise);\n      void this._sendingPromises.splice(index, 1);\n    };\n    promise.then(popPromise, popPromise);\n  }\n\n  public hasReachedLimit(): boolean {\n    return this._sendingPromises.length >= this._concurrencyLimit;\n  }\n\n  public async awaitAll(): Promise<void> {\n    await Promise.all(this._sendingPromises);\n  }\n}\n\n/**\n * Promise queue for keeping track of export promises. Finished promises will be auto-dequeued.\n * Allows for awaiting all promises in the queue.\n */\nexport function createBoundedQueueExportPromiseHandler(options: {\n  concurrencyLimit: number;\n}): IExportPromiseHandler {\n  return new BoundedQueueExportPromiseHandler(options.concurrencyLimit);\n}\n"]}

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-browser-http-options.d.ts

@@ -0,0 +1,11 @@
+import { OtlpHttpConfiguration } from './otlp-http-configuration';
+import { OTLPExporterNodeConfigBase } from './legacy-node-configuration';
+/**
+ * @deprecated this will be removed in 2.0
+ *
+ * @param config
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+export declare function convertLegacyBrowserHttpOptions(config: OTLPExporterNodeConfigBase, signalResourcePath: string, requiredHeaders: Record<string, string>): OtlpHttpConfiguration;
+//# sourceMappingURL=convert-legacy-browser-http-options.d.ts.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-browser-http-options.js

@@ -0,0 +1,34 @@
+/*
+ * 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.
+ */
+import { getHttpConfigurationDefaults, mergeOtlpHttpConfigurationWithDefaults, } from './otlp-http-configuration';
+import { wrapStaticHeadersInFunction } from './shared-configuration';
+/**
+ * @deprecated this will be removed in 2.0
+ *
+ * @param config
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+export function convertLegacyBrowserHttpOptions(config, signalResourcePath, requiredHeaders) {
+    return mergeOtlpHttpConfigurationWithDefaults({
+        url: config.url,
+        timeoutMillis: config.timeoutMillis,
+        headers: wrapStaticHeadersInFunction(config.headers),
+        concurrencyLimit: config.concurrencyLimit,
+    }, {}, // no fallback for browser case
+    getHttpConfigurationDefaults(requiredHeaders, signalResourcePath));
+}
+//# sourceMappingURL=convert-legacy-browser-http-options.js.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-browser-http-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-legacy-browser-http-options.js","sourceRoot":"","sources":["../../../src/configuration/convert-legacy-browser-http-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EACL,4BAA4B,EAC5B,sCAAsC,GAEvC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,UAAU,+BAA+B,CAC7C,MAAkC,EAClC,kBAA0B,EAC1B,eAAuC;IAEvC,OAAO,sCAAsC,CAC3C;QACE,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,OAAO,EAAE,2BAA2B,CAAC,MAAM,CAAC,OAAO,CAAC;QACpD,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;KAC1C,EACD,EAAE,EAAE,+BAA+B;IACnC,4BAA4B,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAClE,CAAC;AACJ,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  getHttpConfigurationDefaults,\n  mergeOtlpHttpConfigurationWithDefaults,\n  OtlpHttpConfiguration,\n} from './otlp-http-configuration';\nimport { OTLPExporterNodeConfigBase } from './legacy-node-configuration';\nimport { wrapStaticHeadersInFunction } from './shared-configuration';\n\n/**\n * @deprecated this will be removed in 2.0\n *\n * @param config\n * @param signalResourcePath\n * @param requiredHeaders\n */\nexport function convertLegacyBrowserHttpOptions(\n  config: OTLPExporterNodeConfigBase,\n  signalResourcePath: string,\n  requiredHeaders: Record<string, string>\n): OtlpHttpConfiguration {\n  return mergeOtlpHttpConfigurationWithDefaults(\n    {\n      url: config.url,\n      timeoutMillis: config.timeoutMillis,\n      headers: wrapStaticHeadersInFunction(config.headers),\n      concurrencyLimit: config.concurrencyLimit,\n    },\n    {}, // no fallback for browser case\n    getHttpConfigurationDefaults(requiredHeaders, signalResourcePath)\n  );\n}\n"]}

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.d.ts

@@ -0,0 +1,11 @@
+import { OTLPExporterNodeConfigBase } from './legacy-node-configuration';
+import { OtlpNodeHttpConfiguration } from './otlp-node-http-configuration';
+/**
+ * @deprecated this will be removed in 2.0
+ * @param config
+ * @param signalIdentifier
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+export declare function convertLegacyHttpOptions(config: OTLPExporterNodeConfigBase, signalIdentifier: string, signalResourcePath: string, requiredHeaders: Record<string, string>): OtlpNodeHttpConfiguration;
+//# sourceMappingURL=convert-legacy-node-http-options.d.ts.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.js

@@ -0,0 +1,43 @@
+import { diag } from '@opentelemetry/api';
+import { wrapStaticHeadersInFunction } from './shared-configuration';
+import { getNodeHttpConfigurationDefaults, mergeOtlpNodeHttpConfigurationWithDefaults, } from './otlp-node-http-configuration';
+import { httpAgentFactoryFromOptions } from '../index-node-http';
+import { getNodeHttpConfigurationFromEnvironment } from './otlp-node-http-env-configuration';
+function convertLegacyAgentOptions(config) {
+    if (typeof config.httpAgentOptions === 'function') {
+        return config.httpAgentOptions;
+    }
+    let legacy = config.httpAgentOptions;
+    if (config.keepAlive != null) {
+        legacy = { keepAlive: config.keepAlive, ...legacy };
+    }
+    if (legacy != null) {
+        return httpAgentFactoryFromOptions(legacy);
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * @deprecated this will be removed in 2.0
+ * @param config
+ * @param signalIdentifier
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+export function convertLegacyHttpOptions(config, signalIdentifier, signalResourcePath, requiredHeaders) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (config.metadata) {
+        diag.warn('Metadata cannot be set when using http');
+    }
+    return mergeOtlpNodeHttpConfigurationWithDefaults({
+        url: config.url,
+        headers: wrapStaticHeadersInFunction(config.headers),
+        concurrencyLimit: config.concurrencyLimit,
+        timeoutMillis: config.timeoutMillis,
+        compression: config.compression,
+        agentFactory: convertLegacyAgentOptions(config),
+        userAgent: config.userAgent,
+    }, getNodeHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath), getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath));
+}
+//# sourceMappingURL=convert-legacy-node-http-options.js.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-legacy-node-http-options.js","sourceRoot":"","sources":["../../../src/configuration/convert-legacy-node-http-options.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EACL,gCAAgC,EAEhC,0CAA0C,GAE3C,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,uCAAuC,EAAE,MAAM,oCAAoC,CAAC;AAE7F,SAAS,yBAAyB,CAChC,MAAkC;IAElC,IAAI,OAAO,MAAM,CAAC,gBAAgB,KAAK,UAAU,EAAE;QACjD,OAAO,MAAM,CAAC,gBAAgB,CAAC;KAChC;IAED,IAAI,MAAM,GAAG,MAAM,CAAC,gBAAgB,CAAC;IACrC,IAAI,MAAM,CAAC,SAAS,IAAI,IAAI,EAAE;QAC5B,MAAM,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,GAAG,MAAM,EAAE,CAAC;KACrD;IAED,IAAI,MAAM,IAAI,IAAI,EAAE;QAClB,OAAO,2BAA2B,CAAC,MAAM,CAAC,CAAC;KAC5C;SAAM;QACL,OAAO,SAAS,CAAC;KAClB;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CACtC,MAAkC,EAClC,gBAAwB,EACxB,kBAA0B,EAC1B,eAAuC;IAEvC,8DAA8D;IAC9D,IAAK,MAAc,CAAC,QAAQ,EAAE;QAC5B,IAAI,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;KACrD;IAED,OAAO,0CAA0C,CAC/C;QACE,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,OAAO,EAAE,2BAA2B,CAAC,MAAM,CAAC,OAAO,CAAC;QACpD,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;QACzC,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,YAAY,EAAE,yBAAyB,CAAC,MAAM,CAAC;QAC/C,SAAS,EAAE,MAAM,CAAC,SAAS;KAC5B,EACD,uCAAuC,CACrC,gBAAgB,EAChB,kBAAkB,CACnB,EACD,gCAAgC,CAAC,eAAe,EAAE,kBAAkB,CAAC,CACtE,CAAC;AACJ,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { OTLPExporterNodeConfigBase } from './legacy-node-configuration';\nimport { diag } from '@opentelemetry/api';\nimport { wrapStaticHeadersInFunction } from './shared-configuration';\nimport {\n  getNodeHttpConfigurationDefaults,\n  HttpAgentFactory,\n  mergeOtlpNodeHttpConfigurationWithDefaults,\n  OtlpNodeHttpConfiguration,\n} from './otlp-node-http-configuration';\nimport { httpAgentFactoryFromOptions } from '../index-node-http';\nimport { getNodeHttpConfigurationFromEnvironment } from './otlp-node-http-env-configuration';\n\nfunction convertLegacyAgentOptions(\n  config: OTLPExporterNodeConfigBase\n): HttpAgentFactory | undefined {\n  if (typeof config.httpAgentOptions === 'function') {\n    return config.httpAgentOptions;\n  }\n\n  let legacy = config.httpAgentOptions;\n  if (config.keepAlive != null) {\n    legacy = { keepAlive: config.keepAlive, ...legacy };\n  }\n\n  if (legacy != null) {\n    return httpAgentFactoryFromOptions(legacy);\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * @deprecated this will be removed in 2.0\n * @param config\n * @param signalIdentifier\n * @param signalResourcePath\n * @param requiredHeaders\n */\nexport function convertLegacyHttpOptions(\n  config: OTLPExporterNodeConfigBase,\n  signalIdentifier: string,\n  signalResourcePath: string,\n  requiredHeaders: Record<string, string>\n): OtlpNodeHttpConfiguration {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if ((config as any).metadata) {\n    diag.warn('Metadata cannot be set when using http');\n  }\n\n  return mergeOtlpNodeHttpConfigurationWithDefaults(\n    {\n      url: config.url,\n      headers: wrapStaticHeadersInFunction(config.headers),\n      concurrencyLimit: config.concurrencyLimit,\n      timeoutMillis: config.timeoutMillis,\n      compression: config.compression,\n      agentFactory: convertLegacyAgentOptions(config),\n      userAgent: config.userAgent,\n    },\n    getNodeHttpConfigurationFromEnvironment(\n      signalIdentifier,\n      signalResourcePath\n    ),\n    getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath)\n  );\n}\n"]}

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/create-legacy-browser-delegate.d.ts

@@ -0,0 +1,14 @@
+import { ISerializer } from '@opentelemetry/otlp-transformer';
+import { createOtlpSendBeaconExportDelegate } from '../otlp-browser-http-export-delegate';
+import { IOtlpExportDelegate } from '../otlp-export-delegate';
+import { OTLPExporterConfigBase } from './legacy-base-configuration';
+/**
+ * @deprecated
+ * @param config
+ * @param serializer
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+export declare function createLegacyOtlpBrowserExportDelegate<Internal, Response>(config: OTLPExporterConfigBase, serializer: ISerializer<Internal, Response>, signalResourcePath: string, requiredHeaders: Record<string, string>): IOtlpExportDelegate<Internal>;
+export declare function inferExportDelegateToUse(configHeaders: OTLPExporterConfigBase['headers']): typeof createOtlpSendBeaconExportDelegate;
+//# sourceMappingURL=create-legacy-browser-delegate.d.ts.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/create-legacy-browser-delegate.js

@@ -0,0 +1,26 @@
+import { createOtlpFetchExportDelegate, createOtlpSendBeaconExportDelegate, createOtlpXhrExportDelegate, } from '../otlp-browser-http-export-delegate';
+import { convertLegacyBrowserHttpOptions } from './convert-legacy-browser-http-options';
+/**
+ * @deprecated
+ * @param config
+ * @param serializer
+ * @param signalResourcePath
+ * @param requiredHeaders
+ */
+export function createLegacyOtlpBrowserExportDelegate(config, serializer, signalResourcePath, requiredHeaders) {
+    const createOtlpExportDelegate = inferExportDelegateToUse(config.headers);
+    const options = convertLegacyBrowserHttpOptions(config, signalResourcePath, requiredHeaders);
+    return createOtlpExportDelegate(options, serializer);
+}
+export function inferExportDelegateToUse(configHeaders) {
+    if (!configHeaders && typeof navigator.sendBeacon === 'function') {
+        return createOtlpSendBeaconExportDelegate;
+    }
+    else if (typeof globalThis.fetch !== 'undefined') {
+        return createOtlpFetchExportDelegate;
+    }
+    else {
+        return createOtlpXhrExportDelegate;
+    }
+}
+//# sourceMappingURL=create-legacy-browser-delegate.js.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/create-legacy-browser-delegate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-legacy-browser-delegate.js","sourceRoot":"","sources":["../../../src/configuration/create-legacy-browser-delegate.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,6BAA6B,EAC7B,kCAAkC,EAClC,2BAA2B,GAC5B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,+BAA+B,EAAE,MAAM,uCAAuC,CAAC;AAIxF;;;;;;GAMG;AACH,MAAM,UAAU,qCAAqC,CACnD,MAA8B,EAC9B,UAA2C,EAC3C,kBAA0B,EAC1B,eAAuC;IAEvC,MAAM,wBAAwB,GAAG,wBAAwB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAE1E,MAAM,OAAO,GAAG,+BAA+B,CAC7C,MAAM,EACN,kBAAkB,EAClB,eAAe,CAChB,CAAC;IAEF,OAAO,wBAAwB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,wBAAwB,CACtC,aAAgD;IAEhD,IAAI,CAAC,aAAa,IAAI,OAAO,SAAS,CAAC,UAAU,KAAK,UAAU,EAAE;QAChE,OAAO,kCAAkC,CAAC;KAC3C;SAAM,IAAI,OAAO,UAAU,CAAC,KAAK,KAAK,WAAW,EAAE;QAClD,OAAO,6BAA6B,CAAC;KACtC;SAAM;QACL,OAAO,2BAA2B,CAAC;KACpC;AACH,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ISerializer } from '@opentelemetry/otlp-transformer';\nimport {\n  createOtlpFetchExportDelegate,\n  createOtlpSendBeaconExportDelegate,\n  createOtlpXhrExportDelegate,\n} from '../otlp-browser-http-export-delegate';\nimport { convertLegacyBrowserHttpOptions } from './convert-legacy-browser-http-options';\nimport { IOtlpExportDelegate } from '../otlp-export-delegate';\nimport { OTLPExporterConfigBase } from './legacy-base-configuration';\n\n/**\n * @deprecated\n * @param config\n * @param serializer\n * @param signalResourcePath\n * @param requiredHeaders\n */\nexport function createLegacyOtlpBrowserExportDelegate<Internal, Response>(\n  config: OTLPExporterConfigBase,\n  serializer: ISerializer<Internal, Response>,\n  signalResourcePath: string,\n  requiredHeaders: Record<string, string>\n): IOtlpExportDelegate<Internal> {\n  const createOtlpExportDelegate = inferExportDelegateToUse(config.headers);\n\n  const options = convertLegacyBrowserHttpOptions(\n    config,\n    signalResourcePath,\n    requiredHeaders\n  );\n\n  return createOtlpExportDelegate(options, serializer);\n}\n\nexport function inferExportDelegateToUse(\n  configHeaders: OTLPExporterConfigBase['headers']\n) {\n  if (!configHeaders && typeof navigator.sendBeacon === 'function') {\n    return createOtlpSendBeaconExportDelegate;\n  } else if (typeof globalThis.fetch !== 'undefined') {\n    return createOtlpFetchExportDelegate;\n  } else {\n    return createOtlpXhrExportDelegate;\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/legacy-base-configuration.d.ts

@@ -0,0 +1,9 @@
+export interface OTLPExporterConfigBase {
+    headers?: Record<string, string>;
+    url?: string;
+    concurrencyLimit?: number;
+    /** Maximum time the OTLP exporter will wait for each batch export.
+     * The default value is 10000ms. */
+    timeoutMillis?: number;
+}
+//# sourceMappingURL=legacy-base-configuration.d.ts.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/legacy-base-configuration.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=legacy-base-configuration.js.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/legacy-base-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-base-configuration.js","sourceRoot":"","sources":["../../../src/configuration/legacy-base-configuration.ts"],"names":[],"mappings":"","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport interface OTLPExporterConfigBase {\n  headers?: Record<string, string>;\n  url?: string;\n  concurrencyLimit?: number;\n  /** Maximum time the OTLP exporter will wait for each batch export.\n   * The default value is 10000ms. */\n  timeoutMillis?: number;\n}\n"]}

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/legacy-node-configuration.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type * as http from 'http';
+import type * as https from 'https';
+import type { OTLPExporterConfigBase } from './legacy-base-configuration';
+import type { HttpAgentFactory } from './otlp-node-http-configuration';
+/**
+ * Collector Exporter node base config
+ */
+export interface OTLPExporterNodeConfigBase extends OTLPExporterConfigBase {
+    keepAlive?: boolean;
+    compression?: CompressionAlgorithm;
+    /**
+     * Custom HTTP agent options or a factory function for creating agents.
+     *
+     * @remarks
+     * Prefer using `http.AgentOptions` or `https.AgentOptions` over a factory function wherever possible.
+     * If using a factory function (`HttpAgentFactory`), **do not import `http.Agent` or `https.Agent`
+     * statically at the top of the file**.
+     * Instead, use dynamic `import()` or `require()` to load the module. This ensures that the `http` or `https`
+     * module is not loaded before `@opentelemetry/instrumentation-http` can instrument it.
+     *
+     * @example <caption> Using agent options directly: </caption>
+     * httpAgentOptions: {
+     *   keepAlive: true,
+     *   maxSockets: 10
+     * }
+     *
+     * @example <caption> Using a factory with dynamic import: </caption>
+     * httpAgentOptions: async (protocol) => {
+     *   const module = protocol === 'http:' ? await import('http') : await import('https');
+     *   return new module.Agent({ keepAlive: true });
+     * }
+     */
+    httpAgentOptions?: http.AgentOptions | https.AgentOptions | HttpAgentFactory;
+    /**
+     * User agent header string to be prepended to the exporter's default value.
+     * Availablie since v1.49.0 of the spec.
+     * Ref: https://opentelemetry.io/docs/specs/otel/protocol/exporter/#user-agent
+     */
+    userAgent?: string;
+}
+export declare enum CompressionAlgorithm {
+    NONE = "none",
+    GZIP = "gzip"
+}
+//# sourceMappingURL=legacy-node-configuration.d.ts.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/legacy-node-configuration.js

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+export var CompressionAlgorithm;
+(function (CompressionAlgorithm) {
+    CompressionAlgorithm["NONE"] = "none";
+    CompressionAlgorithm["GZIP"] = "gzip";
+})(CompressionAlgorithm || (CompressionAlgorithm = {}));
+//# sourceMappingURL=legacy-node-configuration.js.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/legacy-node-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-node-configuration.js","sourceRoot":"","sources":["../../../src/configuration/legacy-node-configuration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA8CH,MAAM,CAAN,IAAY,oBAGX;AAHD,WAAY,oBAAoB;IAC9B,qCAAa,CAAA;IACb,qCAAa,CAAA;AACf,CAAC,EAHW,oBAAoB,KAApB,oBAAoB,QAG/B","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// NOTE: do not change these imports to be actual imports, otherwise they WILL break `@opentelemetry/instrumentation-http`\nimport type * as http from 'http';\nimport type * as https from 'https';\n\nimport type { OTLPExporterConfigBase } from './legacy-base-configuration';\nimport type { HttpAgentFactory } from './otlp-node-http-configuration';\n\n/**\n * Collector Exporter node base config\n */\nexport interface OTLPExporterNodeConfigBase extends OTLPExporterConfigBase {\n  keepAlive?: boolean;\n  compression?: CompressionAlgorithm;\n  /**\n   * Custom HTTP agent options or a factory function for creating agents.\n   *\n   * @remarks\n   * Prefer using `http.AgentOptions` or `https.AgentOptions` over a factory function wherever possible.\n   * If using a factory function (`HttpAgentFactory`), **do not import `http.Agent` or `https.Agent`\n   * statically at the top of the file**.\n   * Instead, use dynamic `import()` or `require()` to load the module. This ensures that the `http` or `https`\n   * module is not loaded before `@opentelemetry/instrumentation-http` can instrument it.\n   *\n   * @example <caption> Using agent options directly: </caption>\n   * httpAgentOptions: {\n   *   keepAlive: true,\n   *   maxSockets: 10\n   * }\n   *\n   * @example <caption> Using a factory with dynamic import: </caption>\n   * httpAgentOptions: async (protocol) => {\n   *   const module = protocol === 'http:' ? await import('http') : await import('https');\n   *   return new module.Agent({ keepAlive: true });\n   * }\n   */\n  httpAgentOptions?: http.AgentOptions | https.AgentOptions | HttpAgentFactory;\n  /**\n   * User agent header string to be prepended to the exporter's default value.\n   * Availablie since v1.49.0 of the spec.\n   * Ref: https://opentelemetry.io/docs/specs/otel/protocol/exporter/#user-agent\n   */\n  userAgent?: string;\n}\n\nexport enum CompressionAlgorithm {\n  NONE = 'none',\n  GZIP = 'gzip',\n}\n"]}

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.d.ts

@@ -0,0 +1,13 @@
+import { OtlpSharedConfiguration } from './shared-configuration';
+export interface OtlpHttpConfiguration extends OtlpSharedConfiguration {
+    url: string;
+    headers: () => Record<string, string>;
+}
+/**
+ * @param userProvidedConfiguration  Configuration options provided by the user in code.
+ * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.
+ * @param defaultConfiguration The defaults as defined by the exporter specification
+ */
+export declare function mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration: Partial<OtlpHttpConfiguration>, fallbackConfiguration: Partial<OtlpHttpConfiguration>, defaultConfiguration: OtlpHttpConfiguration): OtlpHttpConfiguration;
+export declare function getHttpConfigurationDefaults(requiredHeaders: Record<string, string>, signalResourcePath: string): OtlpHttpConfiguration;
+//# sourceMappingURL=otlp-http-configuration.d.ts.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js

@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+import { getSharedConfigurationDefaults, mergeOtlpSharedConfigurationWithDefaults, } from './shared-configuration';
+import { validateAndNormalizeHeaders } from '../util';
+function mergeHeaders(userProvidedHeaders, fallbackHeaders, defaultHeaders) {
+    const requiredHeaders = {
+        ...defaultHeaders(),
+    };
+    const headers = {};
+    return () => {
+        // add fallback ones first
+        if (fallbackHeaders != null) {
+            Object.assign(headers, fallbackHeaders());
+        }
+        // override with user-provided ones
+        if (userProvidedHeaders != null) {
+            Object.assign(headers, userProvidedHeaders());
+        }
+        // override required ones.
+        return Object.assign(headers, requiredHeaders);
+    };
+}
+function validateUserProvidedUrl(url) {
+    if (url == null) {
+        return undefined;
+    }
+    try {
+        // NOTE: In non-browser environments, `globalThis.location` will be `undefined`.
+        const base = globalThis.location?.href;
+        return new URL(url, base).href;
+    }
+    catch {
+        throw new Error(`Configuration: Could not parse user-provided export URL: '${url}'`);
+    }
+}
+/**
+ * @param userProvidedConfiguration  Configuration options provided by the user in code.
+ * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.
+ * @param defaultConfiguration The defaults as defined by the exporter specification
+ */
+export function mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+    return {
+        ...mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
+        headers: mergeHeaders(validateAndNormalizeHeaders(userProvidedConfiguration.headers), fallbackConfiguration.headers, defaultConfiguration.headers),
+        url: validateUserProvidedUrl(userProvidedConfiguration.url) ??
+            fallbackConfiguration.url ??
+            defaultConfiguration.url,
+    };
+}
+export function getHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
+    return {
+        ...getSharedConfigurationDefaults(),
+        headers: () => requiredHeaders,
+        url: 'http://localhost:4318/' + signalResourcePath,
+    };
+}
+//# sourceMappingURL=otlp-http-configuration.js.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp-http-configuration.js","sourceRoot":"","sources":["../../../src/configuration/otlp-http-configuration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,8BAA8B,EAC9B,wCAAwC,GAEzC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAOtD,SAAS,YAAY,CACnB,mBAAsE,EACtE,eAAkE,EAClE,cAA4C;IAE5C,MAAM,eAAe,GAAG;QACtB,GAAG,cAAc,EAAE;KACpB,CAAC;IACF,MAAM,OAAO,GAAG,EAAE,CAAC;IAEnB,OAAO,GAAG,EAAE;QACV,0BAA0B;QAC1B,IAAI,eAAe,IAAI,IAAI,EAAE;YAC3B,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,CAAC,CAAC;SAC3C;QAED,mCAAmC;QACnC,IAAI,mBAAmB,IAAI,IAAI,EAAE;YAC/B,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,mBAAmB,EAAE,CAAC,CAAC;SAC/C;QAED,0BAA0B;QAC1B,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;IACjD,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,uBAAuB,CAAC,GAAuB;IACtD,IAAI,GAAG,IAAI,IAAI,EAAE;QACf,OAAO,SAAS,CAAC;KAClB;IACD,IAAI;QACF,gFAAgF;QAChF,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC;QACvC,OAAO,IAAI,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC;KAChC;IAAC,MAAM;QACN,MAAM,IAAI,KAAK,CACb,6DAA6D,GAAG,GAAG,CACpE,CAAC;KACH;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sCAAsC,CACpD,yBAAyD,EACzD,qBAAqD,EACrD,oBAA2C;IAE3C,OAAO;QACL,GAAG,wCAAwC,CACzC,yBAAyB,EACzB,qBAAqB,EACrB,oBAAoB,CACrB;QACD,OAAO,EAAE,YAAY,CACnB,2BAA2B,CAAC,yBAAyB,CAAC,OAAO,CAAC,EAC9D,qBAAqB,CAAC,OAAO,EAC7B,oBAAoB,CAAC,OAAO,CAC7B;QACD,GAAG,EACD,uBAAuB,CAAC,yBAAyB,CAAC,GAAG,CAAC;YACtD,qBAAqB,CAAC,GAAG;YACzB,oBAAoB,CAAC,GAAG;KAC3B,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,4BAA4B,CAC1C,eAAuC,EACvC,kBAA0B;IAE1B,OAAO;QACL,GAAG,8BAA8B,EAAE;QACnC,OAAO,EAAE,GAAG,EAAE,CAAC,eAAe;QAC9B,GAAG,EAAE,wBAAwB,GAAG,kBAAkB;KACnD,CAAC;AACJ,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  getSharedConfigurationDefaults,\n  mergeOtlpSharedConfigurationWithDefaults,\n  OtlpSharedConfiguration,\n} from './shared-configuration';\nimport { validateAndNormalizeHeaders } from '../util';\n\nexport interface OtlpHttpConfiguration extends OtlpSharedConfiguration {\n  url: string;\n  headers: () => Record<string, string>;\n}\n\nfunction mergeHeaders(\n  userProvidedHeaders: (() => Record<string, string>) | undefined | null,\n  fallbackHeaders: (() => Record<string, string>) | undefined | null,\n  defaultHeaders: () => Record<string, string>\n): () => Record<string, string> {\n  const requiredHeaders = {\n    ...defaultHeaders(),\n  };\n  const headers = {};\n\n  return () => {\n    // add fallback ones first\n    if (fallbackHeaders != null) {\n      Object.assign(headers, fallbackHeaders());\n    }\n\n    // override with user-provided ones\n    if (userProvidedHeaders != null) {\n      Object.assign(headers, userProvidedHeaders());\n    }\n\n    // override required ones.\n    return Object.assign(headers, requiredHeaders);\n  };\n}\n\nfunction validateUserProvidedUrl(url: string | undefined): string | undefined {\n  if (url == null) {\n    return undefined;\n  }\n  try {\n    // NOTE: In non-browser environments, `globalThis.location` will be `undefined`.\n    const base = globalThis.location?.href;\n    return new URL(url, base).href;\n  } catch {\n    throw new Error(\n      `Configuration: Could not parse user-provided export URL: '${url}'`\n    );\n  }\n}\n\n/**\n * @param userProvidedConfiguration  Configuration options provided by the user in code.\n * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.\n * @param defaultConfiguration The defaults as defined by the exporter specification\n */\nexport function mergeOtlpHttpConfigurationWithDefaults(\n  userProvidedConfiguration: Partial<OtlpHttpConfiguration>,\n  fallbackConfiguration: Partial<OtlpHttpConfiguration>,\n  defaultConfiguration: OtlpHttpConfiguration\n): OtlpHttpConfiguration {\n  return {\n    ...mergeOtlpSharedConfigurationWithDefaults(\n      userProvidedConfiguration,\n      fallbackConfiguration,\n      defaultConfiguration\n    ),\n    headers: mergeHeaders(\n      validateAndNormalizeHeaders(userProvidedConfiguration.headers),\n      fallbackConfiguration.headers,\n      defaultConfiguration.headers\n    ),\n    url:\n      validateUserProvidedUrl(userProvidedConfiguration.url) ??\n      fallbackConfiguration.url ??\n      defaultConfiguration.url,\n  };\n}\n\nexport function getHttpConfigurationDefaults(\n  requiredHeaders: Record<string, string>,\n  signalResourcePath: string\n): OtlpHttpConfiguration {\n  return {\n    ...getSharedConfigurationDefaults(),\n    headers: () => requiredHeaders,\n    url: 'http://localhost:4318/' + signalResourcePath,\n  };\n}\n"]}

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-configuration.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { OtlpHttpConfiguration } from './otlp-http-configuration';
+import type * as http from 'http';
+import type * as https from 'https';
+export type HttpAgentFactory = (protocol: string) => http.Agent | https.Agent | Promise<http.Agent> | Promise<https.Agent>;
+export interface OtlpNodeHttpConfiguration extends OtlpHttpConfiguration {
+    /**
+     * Factory function for creating agents.
+     *
+     * @remarks
+     * Prefer using {@link httpAgentFactoryFromOptions} over manually writing a factory function wherever possible.
+     * If using a factory function (`HttpAgentFactory`), **do not import `http.Agent` or `https.Agent`
+     * statically at the top of the file**.
+     * Instead, use dynamic `import()` or `require()` to load the module. This ensures that the `http` or `https`
+     * module is not loaded before `@opentelemetry/instrumentation-http` can instrument it.
+     */
+    agentFactory: HttpAgentFactory;
+    /**
+     * User agent header string to be appended to the exporter's value as a prefix.
+     * Availablie since v1.49.0 of the spec.
+     * Ref: https://opentelemetry.io/docs/specs/otel/protocol/exporter/#user-agent
+     */
+    userAgent?: string;
+}
+export declare function httpAgentFactoryFromOptions(options: http.AgentOptions | https.AgentOptions): HttpAgentFactory;
+/**
+ * @param userProvidedConfiguration  Configuration options provided by the user in code.
+ * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.
+ * @param defaultConfiguration The defaults as defined by the exporter specification
+ */
+export declare function mergeOtlpNodeHttpConfigurationWithDefaults(userProvidedConfiguration: Partial<OtlpNodeHttpConfiguration>, fallbackConfiguration: Partial<OtlpNodeHttpConfiguration>, defaultConfiguration: OtlpNodeHttpConfiguration): OtlpNodeHttpConfiguration;
+export declare function getNodeHttpConfigurationDefaults(requiredHeaders: Record<string, string>, signalResourcePath: string): OtlpNodeHttpConfiguration;
+//# sourceMappingURL=otlp-node-http-configuration.d.ts.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-configuration.js

@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+import { getHttpConfigurationDefaults, mergeOtlpHttpConfigurationWithDefaults, } from './otlp-http-configuration';
+export function httpAgentFactoryFromOptions(options) {
+    return async (protocol) => {
+        const isInsecure = protocol === 'http:';
+        const module = isInsecure ? import('http') : import('https');
+        const { Agent } = await module;
+        if (isInsecure) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars -- these props should not be used in agent options
+            const { ca, cert, key, ...insecureOptions } = options;
+            return new Agent(insecureOptions);
+        }
+        return new Agent(options);
+    };
+}
+/**
+ * @param userProvidedConfiguration  Configuration options provided by the user in code.
+ * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.
+ * @param defaultConfiguration The defaults as defined by the exporter specification
+ */
+export function mergeOtlpNodeHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+    return {
+        ...mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
+        agentFactory: userProvidedConfiguration.agentFactory ??
+            fallbackConfiguration.agentFactory ??
+            defaultConfiguration.agentFactory,
+        userAgent: userProvidedConfiguration.userAgent,
+    };
+}
+export function getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
+    return {
+        ...getHttpConfigurationDefaults(requiredHeaders, signalResourcePath),
+        agentFactory: httpAgentFactoryFromOptions({ keepAlive: true }),
+    };
+}
+//# sourceMappingURL=otlp-node-http-configuration.js.map

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp-node-http-configuration.js","sourceRoot":"","sources":["../../../src/configuration/otlp-node-http-configuration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EACL,4BAA4B,EAC5B,sCAAsC,GAEvC,MAAM,2BAA2B,CAAC;AA8BnC,MAAM,UAAU,2BAA2B,CACzC,OAA+C;IAE/C,OAAO,KAAK,EAAC,QAAQ,EAAC,EAAE;QACtB,MAAM,UAAU,GAAG,QAAQ,KAAK,OAAO,CAAC;QACxC,MAAM,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC7D,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC;QAE/B,IAAI,UAAU,EAAE;YACd,gHAAgH;YAChH,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,eAAe,EAAE,GACzC,OAA6B,CAAC;YAChC,OAAO,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;SACnC;QACD,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,0CAA0C,CACxD,yBAA6D,EAC7D,qBAAyD,EACzD,oBAA+C;IAE/C,OAAO;QACL,GAAG,sCAAsC,CACvC,yBAAyB,EACzB,qBAAqB,EACrB,oBAAoB,CACrB;QACD,YAAY,EACV,yBAAyB,CAAC,YAAY;YACtC,qBAAqB,CAAC,YAAY;YAClC,oBAAoB,CAAC,YAAY;QACnC,SAAS,EAAE,yBAAyB,CAAC,SAAS;KAC/C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,gCAAgC,CAC9C,eAAuC,EACvC,kBAA0B;IAE1B,OAAO;QACL,GAAG,4BAA4B,CAAC,eAAe,EAAE,kBAAkB,CAAC;QACpE,YAAY,EAAE,2BAA2B,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;KAC/D,CAAC;AACJ,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  getHttpConfigurationDefaults,\n  mergeOtlpHttpConfigurationWithDefaults,\n  OtlpHttpConfiguration,\n} from './otlp-http-configuration';\n\n// NOTE: do not change these imports to be actual imports, otherwise they WILL break `@opentelemetry/instrumentation-http`\nimport type * as http from 'http';\nimport type * as https from 'https';\n\nexport type HttpAgentFactory = (\n  protocol: string\n) => http.Agent | https.Agent | Promise<http.Agent> | Promise<https.Agent>;\n\nexport interface OtlpNodeHttpConfiguration extends OtlpHttpConfiguration {\n  /**\n   * Factory function for creating agents.\n   *\n   * @remarks\n   * Prefer using {@link httpAgentFactoryFromOptions} over manually writing a factory function wherever possible.\n   * If using a factory function (`HttpAgentFactory`), **do not import `http.Agent` or `https.Agent`\n   * statically at the top of the file**.\n   * Instead, use dynamic `import()` or `require()` to load the module. This ensures that the `http` or `https`\n   * module is not loaded before `@opentelemetry/instrumentation-http` can instrument it.\n   */\n  agentFactory: HttpAgentFactory;\n  /**\n   * User agent header string to be appended to the exporter's value as a prefix.\n   * Availablie since v1.49.0 of the spec.\n   * Ref: https://opentelemetry.io/docs/specs/otel/protocol/exporter/#user-agent\n   */\n  userAgent?: string;\n}\n\nexport function httpAgentFactoryFromOptions(\n  options: http.AgentOptions | https.AgentOptions\n): HttpAgentFactory {\n  return async protocol => {\n    const isInsecure = protocol === 'http:';\n    const module = isInsecure ? import('http') : import('https');\n    const { Agent } = await module;\n\n    if (isInsecure) {\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- these props should not be used in agent options\n      const { ca, cert, key, ...insecureOptions } =\n        options as https.AgentOptions;\n      return new Agent(insecureOptions);\n    }\n    return new Agent(options);\n  };\n}\n\n/**\n * @param userProvidedConfiguration  Configuration options provided by the user in code.\n * @param fallbackConfiguration Fallback to use when the {@link userProvidedConfiguration} does not specify an option.\n * @param defaultConfiguration The defaults as defined by the exporter specification\n */\nexport function mergeOtlpNodeHttpConfigurationWithDefaults(\n  userProvidedConfiguration: Partial<OtlpNodeHttpConfiguration>,\n  fallbackConfiguration: Partial<OtlpNodeHttpConfiguration>,\n  defaultConfiguration: OtlpNodeHttpConfiguration\n): OtlpNodeHttpConfiguration {\n  return {\n    ...mergeOtlpHttpConfigurationWithDefaults(\n      userProvidedConfiguration,\n      fallbackConfiguration,\n      defaultConfiguration\n    ),\n    agentFactory:\n      userProvidedConfiguration.agentFactory ??\n      fallbackConfiguration.agentFactory ??\n      defaultConfiguration.agentFactory,\n    userAgent: userProvidedConfiguration.userAgent,\n  };\n}\n\nexport function getNodeHttpConfigurationDefaults(\n  requiredHeaders: Record<string, string>,\n  signalResourcePath: string\n): OtlpNodeHttpConfiguration {\n  return {\n    ...getHttpConfigurationDefaults(requiredHeaders, signalResourcePath),\n    agentFactory: httpAgentFactoryFromOptions({ keepAlive: true }),\n  };\n}\n"]}

package/dist/server/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-env-configuration.d.ts

@@ -0,0 +1,9 @@
+import { OtlpNodeHttpConfiguration } from './otlp-node-http-configuration';
+/**
+ * Reads and returns configuration from the environment
+ *
+ * @param signalIdentifier all caps part in environment variables that identifies the signal (e.g.: METRICS, TRACES, LOGS)
+ * @param signalResourcePath signal resource path to append if necessary (e.g.: v1/metrics, v1/traces, v1/logs)
+ */
+export declare function getNodeHttpConfigurationFromEnvironment(signalIdentifier: string, signalResourcePath: string): Partial<OtlpNodeHttpConfiguration>;
+//# sourceMappingURL=otlp-node-http-env-configuration.d.ts.map