@uoa/lambda-tracing 1.5.0 → 2.0.0-beta.0

package/dist/zipkin/zipkin.js

@@ -0,0 +1,116 @@
+"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.ZipkinExporter = void 0;
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/zipkin.ts
+ */
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+const index_1 = require("./platform/index");
+const transform_1 = require("./transform");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const utils_1 = require("./utils");
+/**
+ * Zipkin Exporter
+ */
+class ZipkinExporter {
+    constructor(config = {}) {
+        this.DEFAULT_SERVICE_NAME = 'OpenTelemetry Service';
+        this._sendingPromises = [];
+        this._urlStr = config.url || (0, core_1.getEnv)().OTEL_EXPORTER_ZIPKIN_ENDPOINT;
+        this._send = (0, index_1.prepareSend)(this._urlStr, config.headers);
+        this._serviceName = config.serviceName;
+        this._statusCodeTagName = config.statusCodeTagName || transform_1.defaultStatusCodeTagName;
+        this._statusDescriptionTagName =
+            config.statusDescriptionTagName || transform_1.defaultStatusErrorTagName;
+        this._isShutdown = false;
+        if (typeof config.getExportRequestHeaders === 'function') {
+            this._getHeaders = (0, utils_1.prepareGetHeaders)(config.getExportRequestHeaders);
+        }
+        else {
+            // noop
+            this._beforeSend = function () { };
+        }
+    }
+    /**
+     * Export spans.
+     */
+    export(spans, resultCallback) {
+        const serviceName = String(this._serviceName ||
+            spans[0].resource.attributes[semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME] ||
+            this.DEFAULT_SERVICE_NAME);
+        api_1.diag.debug('Zipkin exporter export');
+        if (this._isShutdown) {
+            setTimeout(() => resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: new Error('Exporter has been shutdown'),
+            }));
+            return;
+        }
+        const promise = new Promise(resolve => {
+            this._sendSpans(spans, serviceName, result => {
+                resolve();
+                resultCallback(result);
+            });
+        });
+        this._sendingPromises.push(promise);
+        const popPromise = () => {
+            const index = this._sendingPromises.indexOf(promise);
+            this._sendingPromises.splice(index, 1);
+        };
+        promise.then(popPromise, popPromise);
+    }
+    /**
+     * Shutdown exporter. Noop operation in this exporter.
+     */
+    shutdown() {
+        api_1.diag.debug('Zipkin exporter shutdown');
+        this._isShutdown = true;
+        return new Promise((resolve, reject) => {
+            Promise.all(this._sendingPromises).then(() => {
+                resolve();
+            }, reject);
+        });
+    }
+    /**
+     * if user defines getExportRequestHeaders in config then this will be called
+     * everytime before send, otherwise it will be replaced with noop in
+     * constructor
+     * @default noop
+     */
+    _beforeSend() {
+        if (this._getHeaders) {
+            this._send = (0, index_1.prepareSend)(this._urlStr, this._getHeaders());
+        }
+    }
+    /**
+     * Transform spans and sends to Zipkin service.
+     */
+    _sendSpans(spans, serviceName, done) {
+        const zipkinSpans = spans.map(span => (0, transform_1.toZipkinSpan)(span, String(span.attributes[semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME] ||
+            span.resource.attributes[semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME] ||
+            serviceName), this._statusCodeTagName, this._statusDescriptionTagName));
+        this._beforeSend();
+        return this._send(zipkinSpans, (result) => {
+            if (done) {
+                return done(result);
+            }
+        });
+    }
+}
+exports.ZipkinExporter = ZipkinExporter;

package/logging.ts

@@ -47,6 +47,11 @@ function getLogReplacementValues(callingModule: NodeModule, logInfo: any): Map<s
         info = infoHeader.toString();
     }
 
+    let message = '-';
+    if (logInfo.message != null) {
+        message = logInfo.message;
+    }
+
     const traceIdLength: number = <number>context.active().getValue(B3_TRACE_ID_LENGTH_KEY);
 
     let logReplacements: Map<string, string> = new Map<string, string>();
@@ -57,7 +62,7 @@ function getLogReplacementValues(callingModule: NodeModule, logInfo: any): Map<s
     logReplacements.set('%traceId', traceId.slice(traceId.length - traceIdLength));
     logReplacements.set('%spanId', spanId);
     logReplacements.set('%info', info);
-    logReplacements.set('%message', logInfo.message.replace(/\n/g, ''));
+    logReplacements.set('%message', message.replace(/\n/g, ''));
 
     return logReplacements;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uoa/lambda-tracing",
-  "version": "1.5.0",
+  "version": "2.0.0-beta.0",
   "description": "Library for logging & distributed tracing in UoA Lambda projects",
   "repository": {
     "type": "git",
@@ -29,10 +29,10 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.1.0",
-    "@opentelemetry/core": "^1.2.0",
+    "@opentelemetry/core": "^1.8.0",
     "@opentelemetry/instrumentation": "^0.28.0",
     "@opentelemetry/instrumentation-aws-lambda": "^0.31.0",
-    "@opentelemetry/sdk-trace-node": "^1.2.0",
+    "@opentelemetry/sdk-trace-node": "^1.8.0",
     "moment": "^2.29.3",
     "winston": "^3.7.2"
   },

package/tracing.ts

@@ -1,13 +1,22 @@
-import {NodeTracerProvider} from '@opentelemetry/sdk-trace-node';
+import {NodeTracerProvider, BatchSpanProcessor} from '@opentelemetry/sdk-trace-node';
 import {AwsLambdaInstrumentation} from '@opentelemetry/instrumentation-aws-lambda';
 import {registerInstrumentations} from '@opentelemetry/instrumentation';
 import {B3_INFO_KEY, UoaB3Propagator} from "./UoaB3Propagator";
 import {context} from "@opentelemetry/api";
+import {AlwaysOnSampler} from "@opentelemetry/sdk-trace-base";
+import {ZipkinExporter} from "./zipkin/zipkin";
+import {SemanticResourceAttributes} from "@opentelemetry/semantic-conventions";
 
-const provider = new NodeTracerProvider();
+const provider = new NodeTracerProvider({sampler: new AlwaysOnSampler()});
 let infoHeader: string | undefined;
 
-export function initializeTracing() {
+export function initializeTracing(serviceName: string) {
+    const options = {
+        url: process.env.zipkinUrl ? process.env.zipkinUrl : 'http://zipkin-uoa-its-nonprod-external-1074907196.ap-southeast-2.elb.amazonaws.com:9411/api/v2/spans',
+        serviceName: serviceName
+    }
+    provider.addSpanProcessor(new BatchSpanProcessor(new ZipkinExporter(options)));
+
     provider.register({
         propagator: new UoaB3Propagator()
     });
@@ -17,6 +26,7 @@ export function initializeTracing() {
             new AwsLambdaInstrumentation({
                 requestHook: (span, { event, context }) => {
                     span.setAttribute('faas.name', context.functionName);
+                    span.setAttribute(SemanticResourceAttributes.SERVICE_NAME, serviceName);
                     infoHeader = undefined; //reset header value in case lambda execution environment maintained since last invocation
                 },
                 responseHook: (span, { err, res }) => {

package/zipkin/platform/index.ts

@@ -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.
+ */
+
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/platform/index.ts
+ */
+
+export * from './node';

package/zipkin/platform/node/index.ts

@@ -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.
+ */
+
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/platform/node/index.ts
+ */
+
+export * from './util';

package/zipkin/platform/node/util.ts

@@ -0,0 +1,98 @@
+/*
+ * 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.
+ */
+
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/platform/node/util.ts
+ */
+
+import { diag } from '@opentelemetry/api';
+import { ExportResult, ExportResultCode } from '@opentelemetry/core';
+import * as http from 'http';
+import * as https from 'https';
+import * as url from 'url';
+import * as zipkinTypes from '../../types';
+
+/**
+ * Prepares send function that will send spans to the remote Zipkin service.
+ * @param urlStr - url to send spans
+ * @param headers - headers
+ * send
+ */
+export function prepareSend(urlStr: string, headers?: Record<string, string>): zipkinTypes.SendFn {
+    const urlOpts = url.parse(urlStr);
+
+    const reqOpts: http.RequestOptions = Object.assign(
+        {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers,
+            },
+        },
+        urlOpts
+    );
+
+    /**
+     * Send spans to the remote Zipkin service.
+     */
+    return function send(
+        zipkinSpans: zipkinTypes.Span[],
+        done: (result: ExportResult) => void
+    ) {
+        if (zipkinSpans.length === 0) {
+            diag.debug('Zipkin send with empty spans');
+            return done({ code: ExportResultCode.SUCCESS });
+        }
+
+        const { request } = reqOpts.protocol === 'http:' ? http : https;
+        const req = request(reqOpts, (res: http.IncomingMessage) => {
+            let rawData = '';
+            res.on('data', chunk => {
+                rawData += chunk;
+            });
+            res.on('end', () => {
+                const statusCode = res.statusCode || 0;
+                diag.debug(`Zipkin response status code: ${statusCode}, body: ${rawData}`);
+
+                // Consider 2xx and 3xx as success.
+                if (statusCode < 400) {
+                    return done({ code: ExportResultCode.SUCCESS });
+                    // Consider 4xx as failed non-retriable.
+                } else {
+                    return done({
+                        code: ExportResultCode.FAILED,
+                        error: new Error(
+                            `Got unexpected status code from zipkin: ${statusCode}`
+                        ),
+                    });
+                }
+            });
+        });
+
+        req.on('error', error => {
+            return done({
+                code: ExportResultCode.FAILED,
+                error,
+            });
+        });
+
+        // Issue request to remote service
+        const payload = JSON.stringify(zipkinSpans);
+        diag.debug(`Zipkin request payload: ${payload}`);
+        req.write(payload, 'utf8');
+        req.end();
+    };
+}

package/zipkin/transform.ts

@@ -0,0 +1,116 @@
+/*
+ * 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.
+ */
+
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/transform.ts
+ *
+ * Modified to handle our traceId length being either 16 or 32 characters
+ */
+
+import * as api from '@opentelemetry/api';
+import { ReadableSpan, TimedEvent } from '@opentelemetry/sdk-trace-base';
+import { hrTimeToMicroseconds } from '@opentelemetry/core';
+import * as zipkinTypes from './types';
+import { Resource } from '@opentelemetry/resources';
+import {context} from "@opentelemetry/api";
+import {B3_TRACE_ID_LENGTH_KEY} from "../UoaB3Propagator";
+
+const ZIPKIN_SPAN_KIND_MAPPING = {
+    [api.SpanKind.CLIENT]: zipkinTypes.SpanKind.CLIENT,
+    [api.SpanKind.SERVER]: zipkinTypes.SpanKind.SERVER,
+    [api.SpanKind.CONSUMER]: zipkinTypes.SpanKind.CONSUMER,
+    [api.SpanKind.PRODUCER]: zipkinTypes.SpanKind.PRODUCER,
+    // When absent, the span is local.
+    //@ts-ignore
+    [api.SpanKind.INTERNAL]: undefined,
+};
+
+export const defaultStatusCodeTagName = 'otel.status_code';
+export const defaultStatusErrorTagName = 'error';
+
+/**
+ * Translate OpenTelemetry ReadableSpan to ZipkinSpan format
+ * @param span Span to be translated
+ */
+export function toZipkinSpan(
+    span: ReadableSpan,
+    serviceName: string,
+    statusCodeTagName: string,
+    statusErrorTagName: string
+): zipkinTypes.Span {
+    const traceIdLength: number = <number>context.active().getValue(B3_TRACE_ID_LENGTH_KEY);
+    let traceId = span.spanContext().traceId.slice(span.spanContext().traceId.length - traceIdLength);
+    const zipkinSpan: zipkinTypes.Span = {
+        traceId: traceId,
+        parentId: span.parentSpanId,
+        name: span.name,
+        id: span.spanContext().spanId,
+        kind: ZIPKIN_SPAN_KIND_MAPPING[span.kind],
+        timestamp: hrTimeToMicroseconds(span.startTime),
+        duration: hrTimeToMicroseconds(span.duration),
+        localEndpoint: { serviceName },
+        tags: _toZipkinTags(
+            span.attributes,
+            span.status,
+            statusCodeTagName,
+            statusErrorTagName,
+            span.resource
+        ),
+        annotations: span.events.length
+            ? _toZipkinAnnotations(span.events)
+            : undefined,
+    };
+
+    return zipkinSpan;
+}
+
+/** Converts OpenTelemetry SpanAttributes and SpanStatus to Zipkin Tags format. */
+export function _toZipkinTags(
+    attributes: api.SpanAttributes,
+    status: api.SpanStatus,
+    statusCodeTagName: string,
+    statusErrorTagName: string,
+    resource: Resource
+): zipkinTypes.Tags {
+    const tags: { [key: string]: string } = {};
+    for (const key of Object.keys(attributes)) {
+        tags[key] = String(attributes[key]);
+    }
+    if (status.code !== api.SpanStatusCode.UNSET) {
+        tags[statusCodeTagName] = String(api.SpanStatusCode[status.code]);
+    }
+    if (status.code === api.SpanStatusCode.ERROR && status.message) {
+        tags[statusErrorTagName] = status.message;
+    }
+
+    Object.keys(resource.attributes).forEach(
+        name => (tags[name] = String(resource.attributes[name]))
+    );
+
+    return tags;
+}
+
+/**
+ * Converts OpenTelemetry Events to Zipkin Annotations format.
+ */
+export function _toZipkinAnnotations(
+    events: TimedEvent[]
+): zipkinTypes.Annotation[] {
+    return events.map(event => ({
+        timestamp: hrTimeToMicroseconds(event.time),
+        value: event.name,
+    }));
+}

package/zipkin/types.ts

@@ -0,0 +1,195 @@
+/*
+ * 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.
+ */
+
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/types.ts
+ */
+
+import { ExportResult } from '@opentelemetry/core';
+
+/**
+ * Exporter config
+ */
+export interface ExporterConfig {
+    headers?: Record<string, string>;
+    serviceName?: string;
+    url?: string;
+    // Optional mapping overrides for OpenTelemetry status code and description.
+    statusCodeTagName?: string;
+    statusDescriptionTagName?: string;
+    getExportRequestHeaders?: () => Record<string, string> | undefined;
+}
+
+/**
+ * Zipkin Span
+ * @see https://github.com/openzipkin/zipkin-api/blob/master/zipkin2-api.yaml
+ */
+export interface Span {
+    /**
+     * Trace identifier, set on all spans within it.
+     */
+    traceId: string;
+    /**
+     * The logical operation this span represents in lowercase (e.g. rpc method).
+     * Leave absent if unknown.
+     */
+    name: string;
+    /**
+     * The parent span ID or absent if this the root span in a trace.
+     */
+    parentId?: string;
+    /**
+     * Unique 64bit identifier for this operation within the trace.
+     */
+    id: string;
+    /**
+     * When present, kind clarifies timestamp, duration and remoteEndpoint.
+     * When absent, the span is local or incomplete.
+     */
+    kind?: SpanKind;
+    /**
+     * Epoch microseconds of the start of this span, possibly absent if
+     * incomplete.
+     */
+    timestamp: number;
+    /**
+     * Duration in microseconds of the critical path, if known.
+     */
+    duration: number;
+    /**
+     * True is a request to store this span even if it overrides sampling policy.
+     * This is true when the `X-B3-Flags` header has a value of 1.
+     */
+    debug?: boolean;
+    /**
+     * True if we are contributing to a span started by another tracer (ex on a
+     * different host).
+     */
+    shared?: boolean;
+    /**
+     * The host that recorded this span, primarily for query by service name.
+     */
+    localEndpoint: Endpoint;
+    /**
+     * Associates events that explain latency with the time they happened.
+     */
+    annotations?: Annotation[];
+    /**
+     * Tags give your span context for search, viewing and analysis.
+     */
+    tags: Tags;
+    /**
+     * TODO: `remoteEndpoint`, do we need to support it?
+     * When an RPC (or messaging) span, indicates the other side of the
+     * connection.
+     */
+}
+
+/**
+ * Associates an event that explains latency with a timestamp.
+ * Unlike log statements, annotations are often codes. Ex. "ws" for WireSend
+ * Zipkin v1 core annotations such as "cs" and "sr" have been replaced with
+ * Span.Kind, which interprets timestamp and duration.
+ */
+export interface Annotation {
+    /**
+     * Epoch microseconds of this event.
+     * For example, 1502787600000000 corresponds to 2017-08-15 09:00 UTC
+     */
+    timestamp: number;
+    /**
+     * Usually a short tag indicating an event, like "error"
+     * While possible to add larger data, such as garbage collection details, low
+     * cardinality event names both keep the size of spans down and also are easy
+     * to search against.
+     */
+    value: string;
+}
+
+/**
+ * The network context of a node in the service graph.
+ */
+export interface Endpoint {
+    /**
+     * Lower-case label of this node in the service graph, such as "favstar".
+     * Leave absent if unknown.
+     * This is a primary label for trace lookup and aggregation, so it should be
+     * intuitive and consistent. Many use a name from service discovery.
+     */
+    serviceName?: string;
+    /**
+     * The text representation of the primary IPv4 address associated with this
+     * connection. Ex. 192.168.99.100 Absent if unknown.
+     */
+    ipv4?: string;
+    /**
+     * The text representation of the primary IPv6 address associated with a
+     * connection. Ex. 2001:db8::c001 Absent if unknown.
+     * Prefer using the ipv4 field for mapped addresses.
+     */
+    port?: number;
+}
+
+/**
+ * Adds context to a span, for search, viewing and analysis.
+ * For example, a key "your_app.version" would let you lookup traces by version.
+ * A tag "sql.query" isn't searchable, but it can help in debugging when viewing
+ * a trace.
+ */
+export interface Tags {
+    [tagKey: string]: unknown;
+}
+
+/**
+ * When present, kind clarifies timestamp, duration and remoteEndpoint. When
+ * absent, the span is local or incomplete. Unlike client and server, there
+ * is no direct critical path latency relationship between producer and
+ * consumer spans.
+ * `CLIENT`
+ *   timestamp is the moment a request was sent to the server.
+ *   duration is the delay until a response or an error was received.
+ *   remoteEndpoint is the server.
+ * `SERVER`
+ *   timestamp is the moment a client request was received.
+ *   duration is the delay until a response was sent or an error.
+ *   remoteEndpoint is the client.
+ * `PRODUCER`
+ *   timestamp is the moment a message was sent to a destination.
+ *   duration is the delay sending the message, such as batching.
+ *   remoteEndpoint is the broker.
+ * `CONSUMER`
+ *   timestamp is the moment a message was received from an origin.
+ *   duration is the delay consuming the message, such as from backlog.
+ *   remoteEndpoint - Represents the broker. Leave serviceName absent if unknown.
+ */
+export enum SpanKind {
+    CLIENT = 'CLIENT',
+    SERVER = 'SERVER',
+    CONSUMER = 'CONSUMER',
+    PRODUCER = 'PRODUCER',
+}
+
+/**
+ * interface for function that will send zipkin spans
+ */
+export type SendFunction = (
+    zipkinSpans: Span[],
+    done: (result: ExportResult) => void
+) => void;
+
+export type GetHeaders = () => Record<string, string> | undefined;
+
+export type SendFn = (zipkinSpans: Span[], done: (result: ExportResult) => void) => void;

package/zipkin/utils.ts

@@ -0,0 +1,29 @@
+/*
+ * 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.
+ */
+
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/utils.ts
+ */
+
+import { GetHeaders } from './types';
+
+export function prepareGetHeaders(
+    getExportRequestHeaders: GetHeaders
+): () => Record<string, string> | undefined {
+    return function () {
+        return getExportRequestHeaders();
+    };
+}