@uoa/lambda-tracing 2.0.0-beta.4 → 2.0.0-beta.5

package/dist/UoaB3Propagator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Class extended from OpenTelemetry B3MultiPropagator so that we can propagate & log the X-B3-Info header
+ *
+ * See {@link https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-propagator-b3/src/B3MultiPropagator.ts}
+ */
+import { Context, TextMapGetter, TextMapPropagator, TextMapSetter } from '@opentelemetry/api';
+export declare const X_B3_TRACE_ID = "x-b3-traceid";
+export declare const X_B3_SPAN_ID = "x-b3-spanid";
+export declare const X_B3_SAMPLED = "x-b3-sampled";
+export declare const X_B3_PARENT_SPAN_ID = "x-b3-parentspanid";
+export declare const X_B3_FLAGS = "x-b3-flags";
+export declare const X_B3_INFO = "x-b3-info";
+export declare const B3_DEBUG_FLAG_KEY: symbol;
+export declare const B3_INFO_KEY: symbol;
+export declare const B3_TRACE_ID_LENGTH_KEY: symbol;
+export declare class UoaB3Propagator implements TextMapPropagator {
+    inject(context: Context, carrier: any, setter: TextMapSetter<any>): void;
+    extract(context: Context, carrier: any, getter: TextMapGetter<any>): Context;
+    fields(): string[];
+}

package/dist/UoaB3Propagator.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UoaB3Propagator = exports.B3_TRACE_ID_LENGTH_KEY = exports.B3_INFO_KEY = exports.B3_DEBUG_FLAG_KEY = exports.X_B3_INFO = exports.X_B3_FLAGS = exports.X_B3_PARENT_SPAN_ID = exports.X_B3_SAMPLED = exports.X_B3_SPAN_ID = exports.X_B3_TRACE_ID = void 0;
+/**
+ * Class extended from OpenTelemetry B3MultiPropagator so that we can propagate & log the X-B3-Info header
+ *
+ * See {@link https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-propagator-b3/src/B3MultiPropagator.ts}
+ */
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+const tracing_1 = require("./tracing");
+const crypto = require('crypto');
+exports.X_B3_TRACE_ID = 'x-b3-traceid';
+exports.X_B3_SPAN_ID = 'x-b3-spanid';
+exports.X_B3_SAMPLED = 'x-b3-sampled';
+exports.X_B3_PARENT_SPAN_ID = 'x-b3-parentspanid';
+exports.X_B3_FLAGS = 'x-b3-flags';
+exports.X_B3_INFO = 'x-b3-info';
+exports.B3_DEBUG_FLAG_KEY = (0, api_1.createContextKey)('B3 Debug Flag');
+exports.B3_INFO_KEY = (0, api_1.createContextKey)('B3 Info Header');
+exports.B3_TRACE_ID_LENGTH_KEY = (0, api_1.createContextKey)('B3 TraceId Header Length');
+const VALID_SAMPLED_VALUES = new Set([true, 'true', 'True', '1', 1]);
+const VALID_UNSAMPLED_VALUES = new Set([false, 'false', 'False', '0', 0]);
+function parseHeader(header) {
+    return Array.isArray(header) ? header[0] : header;
+}
+function getHeaderValue(carrier, getter, key) {
+    const header = getter.get(carrier, key);
+    return parseHeader(header);
+}
+function getTraceIdLength(carrier, getter) {
+    const traceId = getHeaderValue(carrier, getter, exports.X_B3_TRACE_ID);
+    if (typeof traceId === 'string') {
+        if (traceId.length <= 16 || traceId.length > 32) {
+            return 16;
+        }
+        else {
+            return 32;
+        }
+    }
+    return 16;
+}
+function getTraceId(carrier, getter) {
+    const traceId = getHeaderValue(carrier, getter, exports.X_B3_TRACE_ID);
+    if (typeof traceId === 'string') {
+        return traceId.padStart(32, '0');
+    }
+    return '';
+}
+function getSpanId(carrier, getter) {
+    const spanId = getHeaderValue(carrier, getter, exports.X_B3_SPAN_ID);
+    if (typeof spanId === 'string') {
+        return spanId;
+    }
+    return '';
+}
+function getDebug(carrier, getter) {
+    const debug = getHeaderValue(carrier, getter, exports.X_B3_FLAGS);
+    return debug === '1' ? '1' : undefined;
+}
+function getTraceFlags(carrier, getter) {
+    const traceFlags = getHeaderValue(carrier, getter, exports.X_B3_SAMPLED);
+    const debug = getDebug(carrier, getter);
+    if (debug === '1' || VALID_SAMPLED_VALUES.has(traceFlags)) {
+        return api_1.TraceFlags.SAMPLED;
+    }
+    if (traceFlags === undefined || VALID_UNSAMPLED_VALUES.has(traceFlags)) {
+        return api_1.TraceFlags.NONE;
+    }
+    // This indicates to isValidSampledValue that this is not valid
+    return;
+}
+function getInfo(carrier, getter) {
+    const info = getHeaderValue(carrier, getter, exports.X_B3_INFO);
+    if (typeof info === 'string') {
+        return info;
+    }
+    return undefined;
+}
+class UoaB3Propagator {
+    inject(context, carrier, setter) {
+        const spanContext = api_1.trace.getSpanContext(context);
+        if (!spanContext ||
+            !(0, api_1.isSpanContextValid)(spanContext) ||
+            (0, core_1.isTracingSuppressed)(context))
+            return;
+        const debug = context.getValue(exports.B3_DEBUG_FLAG_KEY);
+        const traceIdLength = context.getValue(exports.B3_TRACE_ID_LENGTH_KEY);
+        setter.set(carrier, exports.X_B3_TRACE_ID, spanContext.traceId.slice(spanContext.traceId.length - traceIdLength));
+        setter.set(carrier, exports.X_B3_SPAN_ID, crypto.randomBytes(8).toString('hex'));
+        setter.set(carrier, exports.X_B3_PARENT_SPAN_ID, spanContext.spanId);
+        const info = context.getValue(exports.B3_INFO_KEY);
+        if ((0, tracing_1.getTraceInfoHeader)()) {
+            setter.set(carrier, exports.X_B3_INFO, (0, tracing_1.getTraceInfoHeader)());
+        }
+        else if (info && typeof info === 'string') {
+            setter.set(carrier, exports.X_B3_INFO, info.toString());
+        }
+        // According to the B3 spec, if the debug flag is set,
+        // the sampled flag shouldn't be propagated as well.
+        if (debug === '1') {
+            setter.set(carrier, exports.X_B3_FLAGS, debug);
+        }
+        else if (spanContext.traceFlags !== undefined) {
+            // We set the header only if there is an existing sampling decision.
+            // Otherwise we will omit it => Absent.
+            setter.set(carrier, exports.X_B3_SAMPLED, (api_1.TraceFlags.SAMPLED & spanContext.traceFlags) === api_1.TraceFlags.SAMPLED
+                ? '1'
+                : '0');
+        }
+    }
+    extract(context, carrier, getter) {
+        const traceIdLength = getTraceIdLength(carrier, getter);
+        context = context.setValue(exports.B3_TRACE_ID_LENGTH_KEY, traceIdLength);
+        const traceId = getTraceId(carrier, getter);
+        const spanId = getSpanId(carrier, getter);
+        const traceFlags = getTraceFlags(carrier, getter);
+        const debug = getDebug(carrier, getter);
+        const info = getInfo(carrier, getter);
+        context = context.setValue(exports.B3_DEBUG_FLAG_KEY, debug);
+        if (info) {
+            context = context.setValue(exports.B3_INFO_KEY, info);
+        }
+        return api_1.trace.setSpanContext(context, {
+            traceId,
+            spanId,
+            isRemote: true,
+            traceFlags,
+        });
+    }
+    fields() {
+        return [
+            exports.X_B3_TRACE_ID,
+            exports.X_B3_SPAN_ID,
+            exports.X_B3_FLAGS,
+            exports.X_B3_SAMPLED,
+            exports.X_B3_PARENT_SPAN_ID,
+            exports.X_B3_INFO
+        ];
+    }
+}
+exports.UoaB3Propagator = UoaB3Propagator;

package/dist/logging.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/logging.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const UoaB3Propagator_1 = require("./UoaB3Propagator");
+const tracing_1 = require("./tracing");
+const winston = require('winston');
+const moment = require('moment');
+const path = require('path');
+const { trace, context } = require('@opentelemetry/api');
+const defaultLogPattern = '%date [%thread] %level %class - [[[%traceId,%spanId,%info]]] %message';
+const uoaLogLevels = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3
+};
+const uoaLoggingFormat = function (callingModule) {
+    return winston.format.printf((logInfo) => {
+        let logPattern = process.env.loggingPattern ? process.env.loggingPattern : defaultLogPattern;
+        const logReplacements = getLogReplacementValues(callingModule, logInfo);
+        logReplacements.forEach((value, key) => {
+            logPattern = logPattern.replace(key, value);
+        });
+        return logPattern;
+    });
+};
+function getLogReplacementValues(callingModule, logInfo) {
+    const parts = callingModule.filename.substring(0, callingModule.filename.lastIndexOf('.js')).split(path.sep);
+    const moduleParts = parts.slice(parts.indexOf('src'));
+    let traceId = '-';
+    let spanId = '-';
+    const currentContext = trace.getSpanContext(context.active());
+    if (currentContext) {
+        traceId = currentContext.traceId;
+        spanId = currentContext.spanId;
+    }
+    let info = '-';
+    const infoHeader = context.active().getValue(UoaB3Propagator_1.B3_INFO_KEY);
+    if ((0, tracing_1.getTraceInfoHeader)()) {
+        info = (0, tracing_1.getTraceInfoHeader)();
+    }
+    else if (infoHeader) {
+        info = infoHeader.toString();
+    }
+    let message = '-';
+    if (logInfo.message != null) {
+        message = logInfo.message;
+    }
+    const traceIdLength = context.active().getValue(UoaB3Propagator_1.B3_TRACE_ID_LENGTH_KEY);
+    let logReplacements = new Map();
+    logReplacements.set('%date', moment().toISOString());
+    logReplacements.set('%thread', '-');
+    logReplacements.set('%level', logInfo.level.toUpperCase());
+    logReplacements.set('%class', moduleParts.join('.'));
+    logReplacements.set('%traceId', traceId.slice(traceId.length - traceIdLength));
+    logReplacements.set('%spanId', spanId);
+    logReplacements.set('%info', info);
+    logReplacements.set('%message', message.replace(/\n/g, ''));
+    return logReplacements;
+}
+module.exports = function (callingModule) {
+    return winston.createLogger({
+        levels: uoaLogLevels,
+        transports: [
+            new winston.transports.Console({
+                level: process.env.loggingLevel ? process.env.loggingLevel.toLowerCase() : 'info'
+            })
+        ],
+        format: uoaLoggingFormat(callingModule)
+    });
+};

package/dist/tracing.d.ts

@@ -0,0 +1,3 @@
+export declare function initializeTracing(serviceName: string): void;
+export declare function getTraceInfoHeader(): string;
+export declare function setTraceInfoHeader(info: string): void;

package/dist/tracing.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTraceInfoHeader = exports.getTraceInfoHeader = exports.initializeTracing = void 0;
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const instrumentation_aws_lambda_1 = require("@opentelemetry/instrumentation-aws-lambda");
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const UoaB3Propagator_1 = require("./UoaB3Propagator");
+const api_1 = require("@opentelemetry/api");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const zipkin_1 = require("./zipkin/zipkin");
+const provider = new sdk_trace_node_1.NodeTracerProvider({ sampler: new sdk_trace_base_1.AlwaysOnSampler() });
+let infoHeader;
+function initializeTracing(serviceName) {
+    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 sdk_trace_node_1.BatchSpanProcessor(new zipkin_1.ZipkinExporter(options)));
+    provider.register({
+        propagator: new UoaB3Propagator_1.UoaB3Propagator()
+    });
+    (0, instrumentation_1.registerInstrumentations)({
+        instrumentations: [
+            new instrumentation_aws_lambda_1.AwsLambdaInstrumentation({
+                requestHook: (span, { event, context }) => {
+                    span.setAttribute('faas.name', context.functionName);
+                    infoHeader = undefined; //reset header value in case lambda execution environment maintained since last invocation
+                },
+                responseHook: (span, { err, res }) => {
+                    if (err instanceof Error)
+                        span.setAttribute('faas.error', err.message);
+                    if (res)
+                        span.setAttribute('faas.res', res);
+                },
+                disableAwsContextPropagation: true
+            })
+        ]
+    });
+}
+exports.initializeTracing = initializeTracing;
+function getTraceInfoHeader() {
+    if (infoHeader) {
+        return infoHeader;
+    }
+    else {
+        return api_1.context.active().getValue(UoaB3Propagator_1.B3_INFO_KEY);
+    }
+}
+exports.getTraceInfoHeader = getTraceInfoHeader;
+function setTraceInfoHeader(info) {
+    infoHeader = info;
+}
+exports.setTraceInfoHeader = setTraceInfoHeader;

package/dist/uoaHttps.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/uoaHttps.js

@@ -0,0 +1,222 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const https = __importStar(require("https"));
+const api_1 = require("@opentelemetry/api");
+function request(...args) {
+    if (args[2]) {
+        api_1.propagation.inject(api_1.context.active(), args[1].headers);
+        return https.request(args[0], args[1], args[2]);
+    }
+    else {
+        api_1.propagation.inject(api_1.context.active(), args[0].headers);
+        return https.request(args[0], args[1]);
+    }
+}
+function doGetRequest(hostname, path, headers, port = 443) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise(function (resolve, reject) {
+            const options = {
+                "method": "GET",
+                "hostname": hostname,
+                "path": path,
+                "headers": headers,
+                "port": port
+            };
+            api_1.propagation.inject(api_1.context.active(), options.headers);
+            const req = https.request(options, function (response) {
+                const chunks = [];
+                response.on("data", function (chunk) {
+                    chunks.push(chunk);
+                });
+                response.on("end", function () {
+                    let body = Buffer.concat(chunks);
+                    body = JSON.parse(body.toString());
+                    resolve(body);
+                });
+                response.on("error", function (e) {
+                    reject(e);
+                });
+            });
+            req.end();
+        });
+    });
+}
+function doPostRequest(hostname, path, headers, data, port = 443) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise(function (resolve, reject) {
+            const options = {
+                "method": "POST",
+                "hostname": hostname,
+                "path": path,
+                "headers": headers,
+                "port": port
+            };
+            api_1.propagation.inject(api_1.context.active(), options.headers);
+            const req = https.request(options, function (response) {
+                const chunks = [];
+                response.on("data", function (chunk) {
+                    chunks.push(chunk);
+                });
+                response.on("end", function () {
+                    if (response.statusCode == 204) {
+                        //204 is no content, and most JSON parses blow up on an empty string
+                        resolve(null);
+                    }
+                    else {
+                        let body = Buffer.concat(chunks);
+                        if (!('Content-Type' in options.headers) || options.headers['Content-Type'] === 'application/json') {
+                            body = JSON.parse(body.toString());
+                        }
+                        else {
+                            body = body.toString();
+                        }
+                        resolve(body);
+                    }
+                });
+                response.on("error", function (e) {
+                    reject(e);
+                });
+            });
+            if (data) {
+                if (!('Content-Type' in options.headers) || options.headers['Content-Type'] === 'application/json') {
+                    //We serialize using JSON.stringify as a default, or if a JSON is specified
+                    req.write(JSON.stringify(data));
+                }
+                else {
+                    // If another content-type is specified however, we respect the serialization provided
+                    req.write(data);
+                }
+            }
+            req.end();
+        });
+    });
+}
+function doPutRequest(hostname, path, headers, data, port = 443) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise(function (resolve, reject) {
+            const options = {
+                "method": "PUT",
+                "hostname": hostname,
+                "path": path,
+                "headers": headers,
+                "port": port
+            };
+            api_1.propagation.inject(api_1.context.active(), options.headers);
+            const req = https.request(options, function (response) {
+                const chunks = [];
+                response.on("data", function (chunk) {
+                    chunks.push(chunk);
+                });
+                response.on("end", function () {
+                    if (response.statusCode == 204) {
+                        //204 is no content, and most JSON parses blow up on an empty string
+                        resolve(null);
+                    }
+                    else {
+                        let body = Buffer.concat(chunks);
+                        if (!('Content-Type' in options.headers) || options.headers['Content-Type'] === 'application/json') {
+                            body = JSON.parse(body.toString());
+                        }
+                        else {
+                            body = body.toString();
+                        }
+                        resolve(body);
+                    }
+                });
+                response.on("error", function (e) {
+                    reject(e);
+                });
+            });
+            if (data) {
+                if (!('Content-Type' in options.headers) || options.headers['Content-Type'] === 'application/json') {
+                    //We serialize using JSON.stringify as a default, or if a JSON is specified
+                    req.write(JSON.stringify(data));
+                }
+                else {
+                    // If another content-type is specified however, we respect the serialization provided
+                    req.write(data);
+                }
+            }
+            req.end();
+        });
+    });
+}
+function doDeleteRequest(hostname, path, headers, port = 443) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise(function (resolve, reject) {
+            const options = {
+                "method": "DELETE",
+                "hostname": hostname,
+                "path": path,
+                "headers": headers,
+                "port": port
+            };
+            api_1.propagation.inject(api_1.context.active(), options.headers);
+            const req = https.request(options, function (response) {
+                const chunks = [];
+                response.on("data", function (chunk) {
+                    chunks.push(chunk);
+                });
+                response.on("end", function () {
+                    if (response.statusCode == 204) {
+                        //204 is no content, and most JSON parses blow up on an empty string
+                        resolve(null);
+                    }
+                    else {
+                        let body = Buffer.concat(chunks);
+                        if (!('Content-Type' in options.headers) || options.headers['Content-Type'] === 'application/json') {
+                            body = JSON.parse(body.toString());
+                        }
+                        else {
+                            body = body.toString();
+                        }
+                        resolve(body);
+                    }
+                });
+                response.on("error", function (e) {
+                    reject(e);
+                });
+            });
+            req.end();
+        });
+    });
+}
+module.exports = {
+    request,
+    doGetRequest,
+    doPostRequest,
+    doPutRequest,
+    doDeleteRequest
+};

package/dist/zipkin/platform/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/platform/index.ts
+ */
+export * from './node';

package/dist/zipkin/platform/index.js

@@ -0,0 +1,35 @@
+"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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/platform/index.ts
+ */
+__exportStar(require("./node"), exports);

package/dist/zipkin/platform/node/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/platform/node/index.ts
+ */
+export * from './util';

package/dist/zipkin/platform/node/index.js

@@ -0,0 +1,35 @@
+"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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/platform/node/index.ts
+ */
+__exportStar(require("./util"), exports);

package/dist/zipkin/platform/node/util.d.ts

@@ -0,0 +1,8 @@
+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 declare function prepareSend(urlStr: string, headers?: Record<string, string>): zipkinTypes.SendFn;

package/dist/zipkin/platform/node/util.js

@@ -0,0 +1,105 @@
+"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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSend = void 0;
+/**
+ * Copied from https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/src/platform/node/util.ts
+ */
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const url = __importStar(require("url"));
+/**
+ * Prepares send function that will send spans to the remote Zipkin service.
+ * @param urlStr - url to send spans
+ * @param headers - headers
+ * send
+ */
+function prepareSend(urlStr, headers) {
+    const urlOpts = url.parse(urlStr);
+    const reqOpts = Object.assign({
+        method: 'POST',
+        headers: Object.assign({ 'Content-Type': 'application/json' }, headers),
+    }, urlOpts);
+    /**
+     * Send spans to the remote Zipkin service.
+     */
+    return function send(zipkinSpans, done) {
+        if (zipkinSpans.length === 0) {
+            api_1.diag.debug('Zipkin send with empty spans');
+            return done({ code: core_1.ExportResultCode.SUCCESS });
+        }
+        const { request } = reqOpts.protocol === 'http:' ? http : https;
+        const req = request(reqOpts, (res) => {
+            let rawData = '';
+            res.on('data', chunk => {
+                rawData += chunk;
+            });
+            res.on('end', () => {
+                const statusCode = res.statusCode || 0;
+                api_1.diag.debug(`Zipkin response status code: ${statusCode}, body: ${rawData}`);
+                // Consider 2xx and 3xx as success.
+                if (statusCode < 400) {
+                    return done({ code: core_1.ExportResultCode.SUCCESS });
+                    // Consider 4xx as failed non-retriable.
+                }
+                else {
+                    return done({
+                        code: core_1.ExportResultCode.FAILED,
+                        error: new Error(`Got unexpected status code from zipkin: ${statusCode}`),
+                    });
+                }
+            });
+        });
+        req.on('error', error => {
+            return done({
+                code: core_1.ExportResultCode.FAILED,
+                error,
+            });
+        });
+        // Issue request to remote service
+        const payload = JSON.stringify(zipkinSpans);
+        api_1.diag.debug(`Zipkin request payload: ${payload}`);
+        req.write(payload, 'utf8');
+        req.end();
+    };
+}
+exports.prepareSend = prepareSend;

package/dist/zipkin/transform.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 * as zipkinTypes from './types';
+import { Resource } from '@opentelemetry/resources';
+export declare const defaultStatusCodeTagName = "otel.status_code";
+export declare const defaultStatusErrorTagName = "error";
+/**
+ * Translate OpenTelemetry ReadableSpan to ZipkinSpan format
+ * @param span Span to be translated
+ */
+export declare function toZipkinSpan(span: ReadableSpan, serviceName: string, statusCodeTagName: string, statusErrorTagName: string): zipkinTypes.Span;
+/** Converts OpenTelemetry SpanAttributes and SpanStatus to Zipkin Tags format. */
+export declare function _toZipkinTags(attributes: api.SpanAttributes, status: api.SpanStatus, statusCodeTagName: string, statusErrorTagName: string, resource: Resource): zipkinTypes.Tags;
+/**
+ * Converts OpenTelemetry Events to Zipkin Annotations format.
+ */
+export declare function _toZipkinAnnotations(events: TimedEvent[]): zipkinTypes.Annotation[];

package/dist/zipkin/transform.js

@@ -0,0 +1,112 @@
+"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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._toZipkinAnnotations = exports._toZipkinTags = exports.toZipkinSpan = exports.defaultStatusErrorTagName = exports.defaultStatusCodeTagName = void 0;
+/**
+ * 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
+ */
+const api = __importStar(require("@opentelemetry/api"));
+const core_1 = require("@opentelemetry/core");
+const zipkinTypes = __importStar(require("./types"));
+const api_1 = require("@opentelemetry/api");
+const UoaB3Propagator_1 = require("../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,
+};
+exports.defaultStatusCodeTagName = 'otel.status_code';
+exports.defaultStatusErrorTagName = 'error';
+/**
+ * Translate OpenTelemetry ReadableSpan to ZipkinSpan format
+ * @param span Span to be translated
+ */
+function toZipkinSpan(span, serviceName, statusCodeTagName, statusErrorTagName) {
+    const traceIdLength = api_1.context.active().getValue(UoaB3Propagator_1.B3_TRACE_ID_LENGTH_KEY);
+    let traceId = span.spanContext().traceId.slice(span.spanContext().traceId.length - traceIdLength);
+    const zipkinSpan = {
+        traceId: traceId,
+        parentId: span.parentSpanId,
+        name: span.name,
+        id: span.spanContext().spanId,
+        kind: ZIPKIN_SPAN_KIND_MAPPING[span.kind],
+        timestamp: (0, core_1.hrTimeToMicroseconds)(span.startTime),
+        duration: (0, core_1.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;
+}
+exports.toZipkinSpan = toZipkinSpan;
+/** Converts OpenTelemetry SpanAttributes and SpanStatus to Zipkin Tags format. */
+function _toZipkinTags(attributes, status, statusCodeTagName, statusErrorTagName, resource) {
+    const tags = {};
+    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;
+}
+exports._toZipkinTags = _toZipkinTags;
+/**
+ * Converts OpenTelemetry Events to Zipkin Annotations format.
+ */
+function _toZipkinAnnotations(events) {
+    return events.map(event => ({
+        timestamp: (0, core_1.hrTimeToMicroseconds)(event.time),
+        value: event.name,
+    }));
+}
+exports._toZipkinAnnotations = _toZipkinAnnotations;

package/dist/zipkin/types.d.ts

@@ -0,0 +1,160 @@
+/**
+ * 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;
+    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;
+}
+/**
+ * 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 declare enum SpanKind {
+    CLIENT = "CLIENT",
+    SERVER = "SERVER",
+    CONSUMER = "CONSUMER",
+    PRODUCER = "PRODUCER"
+}
+/**
+ * interface for function that will send zipkin spans
+ */
+export declare type SendFunction = (zipkinSpans: Span[], done: (result: ExportResult) => void) => void;
+export declare type GetHeaders = () => Record<string, string> | undefined;
+export declare type SendFn = (zipkinSpans: Span[], done: (result: ExportResult) => void) => void;

package/dist/zipkin/types.js

@@ -0,0 +1,47 @@
+"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.SpanKind = void 0;
+/**
+ * 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.
+ */
+var SpanKind;
+(function (SpanKind) {
+    SpanKind["CLIENT"] = "CLIENT";
+    SpanKind["SERVER"] = "SERVER";
+    SpanKind["CONSUMER"] = "CONSUMER";
+    SpanKind["PRODUCER"] = "PRODUCER";
+})(SpanKind = exports.SpanKind || (exports.SpanKind = {}));

package/dist/zipkin/utils.d.ts

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

package/dist/zipkin/utils.js

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

package/dist/zipkin/zipkin.d.ts

@@ -0,0 +1,37 @@
+import { ExportResult } from '@opentelemetry/core';
+import { SpanExporter, ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import * as zipkinTypes from './types';
+/**
+ * Zipkin Exporter
+ */
+export declare class ZipkinExporter implements SpanExporter {
+    private readonly DEFAULT_SERVICE_NAME;
+    private readonly _statusCodeTagName;
+    private readonly _statusDescriptionTagName;
+    private _urlStr;
+    private _send;
+    private _getHeaders;
+    private _serviceName?;
+    private _isShutdown;
+    private _sendingPromises;
+    constructor(config?: zipkinTypes.ExporterConfig);
+    /**
+     * Export spans.
+     */
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    /**
+     * Shutdown exporter. Noop operation in this exporter.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * 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
+     */
+    private _beforeSend;
+    /**
+     * Transform spans and sends to Zipkin service.
+     */
+    private _sendSpans;
+}

package/dist/zipkin/zipkin.js

@@ -0,0 +1,118 @@
+"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
+ *
+ * Modified to prioritise input serviceName over SemanticResourceAttributes.SERVICE_NAME
+ */
+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(serviceName ||
+            span.attributes[semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME] ||
+            span.resource.attributes[semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME]), this._statusCodeTagName, this._statusDescriptionTagName));
+        this._beforeSend();
+        return this._send(zipkinSpans, (result) => {
+            if (done) {
+                return done(result);
+            }
+        });
+    }
+}
+exports.ZipkinExporter = ZipkinExporter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uoa/lambda-tracing",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.5",
   "description": "Library for logging & distributed tracing in UoA Lambda projects",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "types": "dist/tracing.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "prepublish": "tsc"
+    "prepare": "tsc"
   },
   "exports": {
     ".": "./dist/tracing.js",