feat(otlp-exporter-base): add custom fetch option to OTLP HTTP exporters

Author: zakcutner

experimental/CHANGELOG.md

@@ -15,6 +15,7 @@ For notes on migrating to 2.x / 0.200.x see [the upgrade guide](doc/upgrade-to-2
 
 ### :rocket: Features
 
+* feat(otlp-exporter-base): add custom `fetch` option to OTLP HTTP exporters
 feat(configuration): parse config for rc 3 [#6304](https://github.com/open-telemetry/opentelemetry-js/pull/6304) @maryliag
 
 ### :bug: Bug Fixes

experimental/packages/exporter-logs-otlp-http/README.md

@@ -32,13 +32,14 @@ import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
 
 // exporter options. see all options in OTLPExporterConfigBase
 const collectorOptions = {
+  fetch: customFetch, // an optional custom fetch implementation - default is globalThis.fetch
   url: '<opentelemetry-collector-url>', // url is optional and can be omitted - default is http://localhost:4318/v1/logs
   headers: {}, // an optional object containing custom headers to be sent with each request
   concurrencyLimit: 1, // an optional limit on pending requests
 };
 const logExporter = new OTLPLogExporter(collectorOptions);
 const loggerProvider = new LoggerProvider({
-  processors: [new BatchRecordProcessor(logExporter)]
+  processors: [new BatchRecordProcessor(logExporter)],
 });
 
 const logger = loggerProvider.getLogger('default', '1.0.0');
@@ -67,7 +68,7 @@ const collectorOptions = {
 };
 const logExporter = new OTLPLogExporter(collectorOptions);
 const loggerProvider = new LoggerProvider({
-  processors: [new BatchRecordProcessor(logExporter)]
+  processors: [new BatchRecordProcessor(logExporter)],
 });
 
 const logger = loggerProvider.getLogger('default', '1.0.0');

experimental/packages/exporter-trace-otlp-http/README.md

@@ -31,6 +31,7 @@ import {
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 
 const collectorOptions = {
+  fetch: customFetch, // an optional custom fetch implementation - default is globalThis.fetch
   url: '<opentelemetry-collector-url>', // url is optional and can be omitted - default is http://localhost:4318/v1/traces
   headers: {}, // an optional object containing custom headers to be sent with each request
   concurrencyLimit: 10, // an optional limit on pending requests
@@ -48,24 +49,29 @@ const provider = new WebTracerProvider({
       scheduledDelayMillis: 500,
       // How long the export can run before it is cancelled
       exportTimeoutMillis: 30000,
-    })
-  ]
+    }),
+  ],
 });
 
 provider.register();
-
 ```
 
 ## Traces in Node - JSON over http
 
 ```js
-const { NodeTracerProvider, BatchSpanProcessor } = require('@opentelemetry/sdk-trace-node');
-const { OTLPTraceExporter } =  require('@opentelemetry/exporter-trace-otlp-http');
+const {
+  NodeTracerProvider,
+  BatchSpanProcessor,
+} = require('@opentelemetry/sdk-trace-node');
+const {
+  OTLPTraceExporter,
+} = require('@opentelemetry/exporter-trace-otlp-http');
 
 const collectorOptions = {
+  fetch: customFetch, // an optional custom fetch implementation - default is globalThis.fetch
   url: '<opentelemetry-collector-url>', // url is optional and can be omitted - default is http://localhost:4318/v1/traces
   headers: {
-    foo: 'bar'
+    foo: 'bar',
   }, // an optional object containing custom headers to be sent with each request will only work with http
   concurrencyLimit: 10, // an optional limit on pending requests
 };
@@ -78,12 +84,11 @@ const provider = new NodeTracerProvider({
       maxQueueSize: 1000,
       // The interval between two consecutive exports
       scheduledDelayMillis: 30000,
-    })
-  ]
+    }),
+  ],
 });
 
 provider.register();
-
 ```
 
 ## GRPC
@@ -138,7 +143,7 @@ To override the default timeout duration, use the following options:
     timeoutMillis: 15000,
     url: '<opentelemetry-collector-url>', // url is optional and can be omitted - default is http://localhost:4318/v1/traces
     headers: {
-      foo: 'bar'
+      foo: 'bar',
     }, // an optional object containing custom headers to be sent with each request will only work with http
     concurrencyLimit: 10, // an optional limit on pending requests
   };
@@ -161,7 +166,7 @@ This retry policy has the following configuration, which there is currently no w
 
 This retry policy first checks if the response has a `'Retry-After'` header. If there is a `'Retry-After'` header, the exporter will wait the amount specified in the `'Retry-After'` header before retrying. If there is no `'Retry-After'` header, the exporter will use an exponential backoff with jitter retry strategy.
 
-  > The exporter will retry exporting within the [exporter timeout configuration](#exporter-timeout-configuration) time.
+> The exporter will retry exporting within the [exporter timeout configuration](#exporter-timeout-configuration) time.
 
 ## Running opentelemetry-collector locally to see the traces
 

experimental/packages/opentelemetry-exporter-metrics-otlp-http/README.md

@@ -26,10 +26,14 @@ the [Collector Trace Exporter for web and node][trace-exporter-url].
 The OTLPMetricExporter in Web expects the endpoint to end in `/v1/metrics`.
 
 ```js
-import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader,
+} from '@opentelemetry/sdk-metrics';
 import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
 
 const collectorOptions = {
+  fetch: customFetch, // an optional custom fetch implementation - default is globalThis.fetch
   url: '<opentelemetry-collector-url>', // url is optional and can be omitted - default is http://localhost:4318/v1/metrics
   headers: {}, // an optional object containing custom headers to be sent with each request
   concurrencyLimit: 1, // an optional limit on pending requests
@@ -47,15 +51,21 @@ const meterProvider = new MeterProvider({
 // Now, start recording data
 const meter = meterProvider.getMeter('example-meter');
 const counter = meter.createCounter('metric_name');
-counter.add(10, { 'key': 'value' });
+counter.add(10, { key: 'value' });
 ```
 
 ## Metrics in Node
 
 ```js
-const { MeterProvider, PeriodicExportingMetricReader } = require('@opentelemetry/sdk-metrics');
-const { OTLPMetricExporter } = require('@opentelemetry/exporter-metrics-otlp-http');
+const {
+  MeterProvider,
+  PeriodicExportingMetricReader,
+} = require('@opentelemetry/sdk-metrics');
+const {
+  OTLPMetricExporter,
+} = require('@opentelemetry/exporter-metrics-otlp-http');
 const collectorOptions = {
+  fetch: customFetch, // an optional custom fetch implementation - default is globalThis.fetch
   url: '<opentelemetry-collector-url>', // url is optional and can be omitted - default is http://localhost:4318/v1/metrics
   concurrencyLimit: 1, // an optional limit on pending requests
 };
@@ -72,8 +82,7 @@ const meterProvider = new MeterProvider({
 // Now, start recording data
 const meter = meterProvider.getMeter('example-meter');
 const counter = meter.createCounter('metric_name');
-counter.add(10, { 'key': 'value' });
-
+counter.add(10, { key: 'value' });
 ```
 
 ## Environment Variable Configuration

experimental/packages/otlp-exporter-base/src/configuration/convert-legacy-browser-http-options.ts

@@ -39,6 +39,7 @@ export function convertLegacyBrowserHttpOptions(
       timeoutMillis: config.timeoutMillis,
       headers: convertLegacyHeaders(config),
       concurrencyLimit: config.concurrencyLimit,
+      fetch: config.fetch,
     },
     {}, // no fallback for browser case
     getHttpConfigurationDefaults(requiredHeaders, signalResourcePath)

experimental/packages/otlp-exporter-base/src/configuration/convert-legacy-node-http-options.ts

@@ -71,6 +71,7 @@ export function convertLegacyHttpOptions(
       compression: config.compression,
       agentFactory: convertLegacyAgentOptions(config),
       userAgent: config.userAgent,
+      fetch: config.fetch,
     },
     getNodeHttpConfigurationFromEnvironment(
       signalIdentifier,

experimental/packages/otlp-exporter-base/src/configuration/legacy-base-configuration.ts

@@ -42,6 +42,24 @@ export interface OTLPExporterConfigBase {
    */
   headers?: Record<string, string> | HeadersFactory;
   url?: string;
+  /**
+   * Custom fetch implementation to use for HTTP requests.
+   *
+   * @remarks
+   * This option allows you to provide a custom fetch function that will be used
+   * instead of the global `fetch`.
+   *
+   * The function must have the same signature as the global `fetch` function.
+   *
+   * @example <caption>Using a custom fetch with request logging:</caption>
+   * fetch: async (input, init) => {
+   *   console.log('Making request to:', input);
+   *   return globalThis.fetch(input, init);
+   * }
+   *
+   * @default globalThis.fetch
+   */
+  fetch?: (input: RequestInfo, init: RequestInit) => Promise<Response>;
   concurrencyLimit?: number;
   /** Maximum time the OTLP exporter will wait for each batch export.
    * The default value is 10000ms. */

experimental/packages/otlp-exporter-base/src/configuration/otlp-http-configuration.ts

@@ -24,6 +24,7 @@ import { validateAndNormalizeHeaders } from '../util';
 export type HeadersFactory = () => Promise<Record<string, string>>;
 
 export interface OtlpHttpConfiguration extends OtlpSharedConfiguration {
+  fetch: (input: RequestInfo, init: RequestInit) => Promise<Response>;
   url: string;
   headers: HeadersFactory;
 }
@@ -97,6 +98,10 @@ export function mergeOtlpHttpConfigurationWithDefaults(
       validateUserProvidedUrl(userProvidedConfiguration.url) ??
       fallbackConfiguration.url ??
       defaultConfiguration.url,
+    fetch:
+      userProvidedConfiguration.fetch ??
+      fallbackConfiguration.fetch ??
+      defaultConfiguration.fetch,
   };
 }
 
@@ -108,5 +113,6 @@ export function getHttpConfigurationDefaults(
     ...getSharedConfigurationDefaults(),
     headers: async () => requiredHeaders,
     url: 'http://localhost:4318/' + signalResourcePath,
+    fetch: globalThis.fetch,
   };
 }

experimental/packages/otlp-exporter-base/src/transport/fetch-transport.ts

@@ -24,6 +24,7 @@ import {
 import { HeadersFactory } from '../configuration/otlp-http-configuration';
 
 export interface FetchTransportParameters {
+  fetch: (input: RequestInfo, init: RequestInit) => Promise<Response>;
   url: string;
   headers: HeadersFactory;
 }
@@ -41,7 +42,7 @@ class FetchTransport implements IExporterTransport {
     try {
       const isBrowserEnvironment = !!globalThis.location;
       const url = new URL(this._parameters.url);
-      const response = await fetch(url.href, {
+      const response = await this._parameters.fetch(url.href, {
         method: 'POST',
         headers: await this._parameters.headers(),
         body: data,

experimental/packages/otlp-exporter-base/test/browser/configuration/convert-legacy-browser-otlp-http-options.test.ts

@@ -0,0 +1,39 @@
+/*
+ * 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 * as assert from 'assert';
+import { convertLegacyBrowserHttpOptions } from '../../../src/configuration/convert-legacy-browser-http-options';
+
+describe('convertLegacyBrowserHttpOptions', function () {
+  it('should pass along custom fetch function', function () {
+    const customFetch = async () => new Response();
+    const options = convertLegacyBrowserHttpOptions(
+      {
+        fetch: customFetch,
+      },
+      'v1/signal',
+      {}
+    );
+
+    assert.strictEqual(options.fetch, customFetch);
+  });
+
+  it('should use default fetch when not provided', function () {
+    const options = convertLegacyBrowserHttpOptions({}, 'v1/signal', {});
+
+    assert.strictEqual(options.fetch, globalThis.fetch);
+  });
+});