feat: dynamic header for OTLPTraceExporter

open-telemetry · Nov 6, 2024 · 371b53f · 371b53f
1 parent fe4d368
commit 371b53f
Show file tree

Hide file tree

Showing 10 changed files with 142 additions and 43 deletions.
diff --git a/experimental/packages/otlp-exporter-base/src/configuration/otlp-http-configuration.ts b/experimental/packages/otlp-exporter-base/src/configuration/otlp-http-configuration.ts
@@ -23,14 +23,14 @@ import { validateAndNormalizeHeaders } from '../util';
 
 export interface OtlpHttpConfiguration extends OtlpSharedConfiguration {
   url: string;
-  headers: Record<string, string>;
+  headers: Record<string, string | Function>;
 }
 
 function mergeHeaders(
-  userProvidedHeaders: Record<string, string> | undefined | null,
-  fallbackHeaders: Record<string, string> | undefined | null,
-  defaultHeaders: Record<string, string>
-): Record<string, string> {
+  userProvidedHeaders: Record<string, string | Function> | undefined | null,
+  fallbackHeaders: Record<string, string | Function> | undefined | null,
+  defaultHeaders: Record<string, string | Function>
+): Record<string, string | Function> {
   const requiredHeaders = {
     ...defaultHeaders,
   };
@@ -93,7 +93,7 @@ export function mergeOtlpHttpConfigurationWithDefaults(
 }
 
 export function getHttpConfigurationDefaults(
-  requiredHeaders: Record<string, string>,
+  requiredHeaders: Record<string, string | Function>,
   signalResourcePath: string
 ): OtlpHttpConfiguration {
   return {

diff --git a/experimental/packages/otlp-exporter-base/src/platform/browser/OTLPExporterBrowserBase.ts b/experimental/packages/otlp-exporter-base/src/platform/browser/OTLPExporterBrowserBase.ts
@@ -80,7 +80,7 @@ export abstract class OTLPExporterBrowserBase<
       // sendBeacon has no way to signal retry, so we do not wrap it in a RetryingTransport
       this._transport = createSendBeaconTransport({
         url: actualConfig.url,
-        blobType: actualConfig.headers['Content-Type'],
+        blobType: actualConfig.headers['Content-Type'] as string,
       });
     }
   }

diff --git a/experimental/packages/otlp-exporter-base/src/platform/browser/xhr-transport.ts b/experimental/packages/otlp-exporter-base/src/platform/browser/xhr-transport.ts
@@ -24,20 +24,44 @@ import {
 
 export interface XhrRequestParameters {
   url: string;
-  headers: Record<string, string>;
+  headers: Record<string, string | Function>;
 }
 
 class XhrTransport implements IExporterTransport {
   constructor(private _parameters: XhrRequestParameters) {}
 
   send(data: Uint8Array, timeoutMillis: number): Promise<ExportResponse> {
-    return new Promise<ExportResponse>(resolve => {
+    return new Promise<ExportResponse>(async resolve => {
       const xhr = new XMLHttpRequest();
       xhr.timeout = timeoutMillis;
       xhr.open('POST', this._parameters.url);
-      Object.entries(this._parameters.headers).forEach(([k, v]) => {
-        xhr.setRequestHeader(k, v);
-      });
+
+      await Promise.all(
+        Object.entries(this._parameters.headers).map(
+          async ([k, v]: [string, string | Function]) => {
+            if (!v) {
+              xhr.setRequestHeader(k, '');
+              return;
+            }
+
+            if (typeof v === 'string' || v instanceof String) {
+              xhr.setRequestHeader(k, v as string);
+              return;
+            }
+
+            try {
+              const result = v();
+              if (result instanceof Promise) {
+                xhr.setRequestHeader(k, String(await Promise.resolve(result)));
+              } else {
+                xhr.setRequestHeader(k, String(result));
+              }
+            } catch (err) {
+              diag.error(`Failed Header [${k}] evaluation caused by: ${err}`);
+            }
+          }
+        )
+      );
 
       xhr.ontimeout = _ => {
         resolve({
@@ -81,7 +105,12 @@ class XhrTransport implements IExporterTransport {
       };
 
       xhr.send(
-        new Blob([data], { type: this._parameters.headers['Content-Type'] })
+        new Blob([data], {
+          type:
+            this._parameters.headers['Content-Type'] instanceof Function
+              ? this._parameters.headers['Content-Type']()
+              : this._parameters.headers['Content-Type'],
+        })
       );
     });
   }

diff --git a/experimental/packages/otlp-exporter-base/src/platform/node/OTLPExporterNodeBase.ts b/experimental/packages/otlp-exporter-base/src/platform/node/OTLPExporterNodeBase.ts
@@ -43,7 +43,7 @@ export abstract class OTLPExporterNodeBase<
   constructor(
     config: OTLPExporterNodeConfigBase = {},
     serializer: ISerializer<ExportItem[], ServiceResponse>,
-    requiredHeaders: Record<string, string>,
+    requiredHeaders: Record<string, string | Function>,
     signalIdentifier: string,
     signalResourcePath: string
   ) {

diff --git a/experimental/packages/otlp-exporter-base/src/platform/node/http-transport-types.ts b/experimental/packages/otlp-exporter-base/src/platform/node/http-transport-types.ts
@@ -28,7 +28,7 @@ export type sendWithHttp = (
 
 export interface HttpRequestParameters {
   url: string;
-  headers: Record<string, string>;
+  headers: Record<string, string | Function>;
   compression: 'gzip' | 'none';
   agentOptions: http.AgentOptions | https.AgentOptions;
 }
diff --git a/experimental/packages/otlp-exporter-base/src/platform/node/http-transport-utils.ts b/experimental/packages/otlp-exporter-base/src/platform/node/http-transport-utils.ts
@@ -24,6 +24,46 @@ import {
   parseRetryAfterToMills,
 } from '../../is-export-retryable';
 import { OTLPExporterError } from '../../types';
+import { diag } from '@opentelemetry/api';
+
+export async function mapHeaders(
+  headers: Record<string, string | Function>
+): Promise<Record<string, string>> {
+  const entries = await Promise.all(
+    Object.entries(headers).map(
+      async ([k, v]: [string, string | Function]): Promise<
+        [string, string]
+      > => {
+        if (!v) {
+          return [k, ''];
+        }
+
+        if (typeof v === 'string' || v instanceof String) {
+          return [k, v as string];
+        }
+
+        const result = v();
+        if (result instanceof Promise) {
+          try {
+            return [k, String(await Promise.resolve(result))];
+          } catch (err) {
+            diag.error(`Failed Header [${k}] evaluation caused by: ${err}`);
+          }
+        }
+
+        return [k, String(result)];
+      }
+    )
+  );
+
+  return entries.reduce(
+    (acc: Record<string, string>, [key, value]: [string, string]) => {
+      acc[key] = value;
+      return acc;
+    },
+    {}
+  );
+}
 
 /**
  * Sends data using http
@@ -33,24 +73,26 @@ import { OTLPExporterError } from '../../types';
  * @param onDone
  * @param timeoutMillis
  */
-export function sendWithHttp(
+export async function sendWithHttp(
   params: HttpRequestParameters,
   agent: http.Agent | https.Agent,
   data: Uint8Array,
   onDone: (response: ExportResponse) => void,
   timeoutMillis: number
-): void {
+): Promise<void> {
   const parsedUrl = new URL(params.url);
   const nodeVersion = Number(process.versions.node.split('.')[0]);
 
+  const headers = await mapHeaders(params.headers);
+
+  diag.info('ALL HEADERS: ' + JSON.stringify(headers));
+
   const options: http.RequestOptions | https.RequestOptions = {
     hostname: parsedUrl.hostname,
     port: parsedUrl.port,
     path: parsedUrl.pathname,
     method: 'POST',
-    headers: {
-      ...params.headers,
-    },
+    headers: headers,
     agent: agent,
   };
 

diff --git a/experimental/packages/otlp-exporter-base/src/types.ts b/experimental/packages/otlp-exporter-base/src/types.ts
@@ -45,7 +45,7 @@ export interface ExportServiceError {
  * Collector Exporter base config
  */
 export interface OTLPExporterConfigBase {
-  headers?: Record<string, string>;
+  headers?: Record<string, string | Function>;
   url?: string;
   concurrencyLimit?: number;
   /** Maximum time the OTLP exporter will wait for each batch export.

diff --git a/experimental/packages/otlp-exporter-base/src/util.ts b/experimental/packages/otlp-exporter-base/src/util.ts
@@ -21,17 +21,23 @@ import { diag } from '@opentelemetry/api';
  * @param partialHeaders
  */
 export function validateAndNormalizeHeaders(
-  partialHeaders: Partial<Record<string, unknown>> = {}
-): Record<string, string> {
-  const headers: Record<string, string> = {};
-  Object.entries(partialHeaders).forEach(([key, value]) => {
-    if (typeof value !== 'undefined') {
-      headers[key] = String(value);
-    } else {
-      diag.warn(
-        `Header "${key}" has invalid value (${value}) and will be ignored`
-      );
+  partialHeaders: Partial<Record<string, string | Function>> = {}
+): Record<string, string | Function> {
+  const headers: Record<string, string | Function> = {};
+  Object.entries(partialHeaders).forEach(
+    ([key, value]: [string, string | Function | undefined]) => {
+      if (typeof value !== 'undefined') {
+        if (value instanceof Function) {
+          headers[key] = value as Function;
+        } else {
+          headers[key] = String(value);
+        }
+      } else {
+        diag.warn(
+          `Header "${key}" has invalid value (${value}) and will be ignored`
+        );
+      }
     }
-  });
+  );
   return headers;
 }
diff --git a/experimental/packages/otlp-exporter-base/test/common/util.test.ts b/experimental/packages/otlp-exporter-base/test/common/util.test.ts
@@ -26,7 +26,7 @@ describe('parseHeaders', function () {
   it('should ignore undefined headers', function () {
     // Need to stub/spy on the underlying logger as the "diag" instance is global
     const spyWarn = sinon.stub(diag, 'warn');
-    const headers: Partial<Record<string, unknown>> = {
+    const headers: Partial<Record<string, string | undefined | any>> = {
       foo1: undefined,
       foo2: 'bar',
       foo3: 1,

diff --git a/packages/opentelemetry-exporter-zipkin/src/platform/browser/util.ts b/packages/opentelemetry-exporter-zipkin/src/platform/browser/util.ts
@@ -28,11 +28,11 @@ import * as zipkinTypes from '../../types';
  * @param headers - headers
  * send
  */
-export function prepareSend(
+export async function prepareSend(
   urlStr: string,
   headers?: Record<string, string>
-): zipkinTypes.SendFn {
-  let xhrHeaders: Record<string, string>;
+): Promise<zipkinTypes.SendFn> {
+  let xhrHeaders: Record<string, string | Function>;
   const useBeacon = typeof navigator.sendBeacon === 'function' && !headers;
   if (headers) {
     xhrHeaders = {
@@ -45,7 +45,7 @@ export function prepareSend(
   /**
    * Send spans to the remote Zipkin service.
    */
-  return function send(
+  return async function send(
     zipkinSpans: zipkinTypes.Span[],
     done: (result: ExportResult) => void
   ) {
@@ -57,7 +57,7 @@ export function prepareSend(
     if (useBeacon) {
       sendWithBeacon(payload, done, urlStr);
     } else {
-      sendWithXhr(payload, done, urlStr, xhrHeaders);
+      await sendWithXhr(payload, done, urlStr, xhrHeaders);
     }
   };
 }
@@ -91,17 +91,39 @@ function sendWithBeacon(
  * @param urlStr
  * @param xhrHeaders
  */
-function sendWithXhr(
+async function sendWithXhr(
   data: string,
   done: (result: ExportResult) => void,
   urlStr: string,
-  xhrHeaders: Record<string, string> = {}
+  xhrHeaders: Record<string, string | Function> = {}
 ) {
   const xhr = new XMLHttpRequest();
   xhr.open('POST', urlStr);
-  Object.entries(xhrHeaders).forEach(([k, v]) => {
-    xhr.setRequestHeader(k, v);
-  });
+
+  await Promise.all(
+    Object.entries(xhrHeaders).map(async ([k, v]) => {
+      if (!v) {
+        xhr.setRequestHeader(k, '');
+        return;
+      }
+
+      if (typeof v === 'string' || v instanceof String) {
+        xhr.setRequestHeader(k, v as string);
+        return;
+      }
+
+      try {
+        const result = v();
+        if (result instanceof Promise) {
+          xhr.setRequestHeader(k, String(await result));
+        } else {
+          xhr.setRequestHeader(k, String(result));
+        }
+      } catch (err) {
+        diag.error(`Failed Header [${k}] evaluation caused by: ${err}`);
+      }
+    })
+  );
 
   xhr.onreadystatechange = () => {
     if (xhr.readyState === XMLHttpRequest.DONE) {