initial commit of actions

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/CHANGELOG.md

@@ -0,0 +1,81 @@
+# Release History
+
+## 1.0.0-preview.13 (2021-07-15)
+
+### Features Added
+
+- Added support for disabling distributed tracing using the AZURE_TRACING_DISABLED environment variable.
+
+### Breaking Changes
+
+- Removed `TestTracer` and `TestSpan` from public API and into `@azure/test-utils`. [PR #16315](https://github.com/Azure/azure-sdk-for-js/pull/16315)
+  - `TestTracer` and `TestSpan` are intended for test support when used by other Azure packages and not intended for use by end users.
+- Removed `setTracer`, @azure/core-tracing will now rely on the `trace` API to fetch a tracer from the global tracer provider. [PR #16347](https://github.com/Azure/azure-sdk-for-js/pull/16347)
+  - If you are using `setTracer`, please use `trace.setGlobalTracerProvider(provider)` instead as described in the OpenTelemetry documentation.
+- Removed `NoOpTracer` and `NoOpSpan` from the public API. Please use `trace.wrapSpanContext(INVALID_SPAN_CONTEXT)` from `@opentelemetry/api` instead. [PR #16315](https://github.com/Azure/azure-sdk-for-js/pull/16315)
+
+## 1.0.0-preview.12 (2021-06-30)
+
+- Update `@opentelemetry/api` to version 1.0.0 [PR #15883](https://github.com/Azure/azure-sdk-for-js/pull/15883)
+  - This version ships with ESM modules and fixes an issue where Angular projects would warn ab out optimization bailouts due to dependencies on CommonJS or AMD.
+
+### Breaking Changes
+
+- Removed `OpenCensusSpanWrapper` and `OpenCensusTracerWrapper` from the public API. Customers using these wrappers should migrate to using `OpenTelemetry` directly. [PR #15770](https://github.com/Azure/azure-sdk-for-js/pull/15770)
+- Update `@azure/core-tracing` to version 1.0.0-preview.12. This brings core-tracing up to date with `@opentelemetry/api@1.0.0`.
+  - `Span#context` was renamed to `Span#spanContext`. This change is supported in `@azure/core-http@1.2.7`.
+
+## 1.0.0-preview.11 (2021-03-30)
+
+### Breaking Changes
+
+- Update @azure/core-tracing to version 1.0.0-preview.11. This brings core-tracing up to date with @opentelemetry/api@1.0.0-rc.0.
+  There are two scenarios that will require changes if you are using tracing:
+  - Previously, you would pass a parent span using the `OperationOptions.tracingOptions.spanOptions.parentSpan` property. This has been
+    changed so that you now specify a parent `Context` using the `OperationOptions.tracingOptions.tracingContext` property instead.
+  - The status code for Spans is no longer of type `CanonicalCode`. Instead, it's now `SpanStatusCode`, which also has a smaller range of values.
+
+## 1.0.0-preview.10 (2021-03-04)
+
+- Internal improvements to make future opentelemetry updates simpler.
+
+## 1.0.0-preview.9 (2020-08-04)
+
+- Update `@opentelemetry/api` to version 0.10.2 [PR 10393](https://github.com/Azure/azure-sdk-for-js/pull/10393)
+
+## 1.0.0-preview.8 (2020-04-28)
+
+- Update `TestSpan` to allow setting span attributes [PR link](https://github.com/Azure/azure-sdk-for-js/pull/6565).
+- [BREAKING] Migrate to OpenTelemetry 0.6 using the new `@opentelemetry/api` package. There were a few breaking changes:
+  - `SpanContext` now requires traceFlags to be set.
+  - `Tracer` has removed `recordSpanData`, `getBinaryFormat`, and `getHttpTextFormat`.
+  - `Tracer.getCurrentSpan` returns `undefined` instead of `null` when unset.
+  - `Link` objects renamed `spanContext` property to `context`.
+
+## 1.0.0-preview.7 (2019-12-03)
+
+- Updated the behavior of how incompatible versions of OpenTelemetry Tracer are handled. Now, errors will be thrown only if the user has manually set a Tracer. This means that incompatible versions will be silently ignored when tracing is not enabled.
+- Updated to use OpenTelemetry 0.2 via the `@opentelemetry/types` package. There were two breaking changes in this update:
+  - `isRecordingEvents` on `Span` was renamed to `isRecording`. [PR link](https://github.com/open-telemetry/opentelemetry-js/pull/454)
+  - `addLink` was removed from `Span` as links are now only allowed to be added during span creation. This is possible by specifying any necessary links inside `SpanOptions`. [PR link](https://github.com/open-telemetry/opentelemetry-js/pull/449)
+
+## 1.0.0-preview.5 (2019-10-22)
+
+- Fixes issue where loading multiple copies of this module could result in the tracer set by `setTracer()` being reset.
+
+## 1.0.0-preview.4 (2019-10-08)
+
+- Remove dependency on the `debug` module to ensure compatibility with IE11
+
+## 1.0.0-preview.3 (2019-10-07)
+
+- Updated to use the latest types from OpenTelemetry (PR [#5182](https://github.com/Azure/azure-sdk-for-js/pull/5182))
+- Clean up and refactored code for easier usage and testability. (PR [#5233](https://github.com/Azure/azure-sdk-for-js/pull/5233) and PR [#5283](https://github.com/Azure/azure-sdk-for-js/pull/5283))
+
+## 1.0.0-preview.2 (2019-09-09)
+
+Updated the `OpenCensusSpanPlugin` & the `NoOpSpanPlugin` to support for retrieving span context. This allows updating of request headers with the right [span context](https://www.w3.org/TR/trace-context/#trace-context-http-headers-format). (PR [#4712](https://github.com/Azure/azure-sdk-for-js/pull/4712))
+
+## 1.0.0-preview.1 (2019-08-05)
+
+Provides low-level interfaces and helper methods for tracing in Azure SDK

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Microsoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/README.md

@@ -0,0 +1,72 @@
+# Azure Core tracing library for JavaScript
+
+This is the core tracing library that provides low-level interfaces and helper methods for tracing in Azure SDK JavaScript libraries which work in the browser and Node.js.
+
+## Getting started
+
+### Installation
+
+Install this library using npm as follows
+
+```
+npm install @azure/core-tracing
+```
+
+## Key Concepts
+
+The `@azure/core-tracing` package supports enabling tracing for Azure SDK packages, using an [OpenTelemetry](https://opentelemetry.io/) `Tracer`.
+
+By default, all libraries log with a `NoOpTracer` that takes no action.
+To change this, you have to use `setTracer` to set a new default `Tracer`.
+
+## Examples
+
+### Example 1 - Setting an OpenTelemetry Tracer
+
+```js
+const opentelemetry = require("@opentelemetry/api");
+const { BasicTracer, SimpleSpanProcessor } = require("@opentelemetry/tracing");
+const { ZipkinExporter } = require("@opentelemetry/exporter-zipkin");
+const { setTracer } = require("@azure/core-tracing");
+
+const exporter = new ZipkinExporter({
+  serviceName: "azure-tracing-sample"
+});
+const tracer = new BasicTracer();
+tracer.addSpanProcessor(new SimpleSpanProcessor(exporter));
+
+setTracer(tracer);
+
+const rootSpan = tracer.startSpan("root");
+const context = opentelemetry.setSpan(opentelemetry.context.active(), rootSpan);
+
+// Call some client library methods and pass rootSpan via tracingOptions.
+
+rootSpan.end();
+exporter.shutdown();
+```
+
+### Example 2 - Passing current Context to library operations
+
+```js
+// Given a BlobClient from @azure/storage-blob
+const result = await blobClient.download(undefined, undefined, {
+  tracingOptions: {
+    tracingContext: context
+  }
+});
+```
+
+## Next steps
+
+You can build and run the tests locally by executing `rushx test`. Explore the `test` folder to see advanced usage and behavior of the public classes.
+
+## Troubleshooting
+
+If you run into issues while using this library, please feel free to [file an issue](https://github.com/Azure/azure-sdk-for-js/issues/new).
+
+## Contributing
+
+If you'd like to contribute to this library, please read the [contributing guide](https://github.com/Azure/azure-sdk-for-js/blob/main/CONTRIBUTING.md) to learn more about how to build and test the code.
+
+![Impressions](https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-js%2Fsdk%2Fcore%2Fcore-tracing%2FREADME.png)

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/dist-esm/src/createSpan.js

@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { SpanKind, setSpan, context as otContext, getTracer } from "./interfaces";
+import { trace, INVALID_SPAN_CONTEXT } from "@opentelemetry/api";
+export function isTracingDisabled() {
+    var _a;
+    if (typeof process === "undefined") {
+        // not supported in browser for now without polyfills
+        return false;
+    }
+    const azureTracingDisabledValue = (_a = process.env.AZURE_TRACING_DISABLED) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (azureTracingDisabledValue === "false" || azureTracingDisabledValue === "0") {
+        return false;
+    }
+    return Boolean(azureTracingDisabledValue);
+}
+/**
+ * Creates a function that can be used to create spans using the global tracer.
+ *
+ * Usage:
+ *
+ * ```typescript
+ * // once
+ * const createSpan = createSpanFunction({ packagePrefix: "Azure.Data.AppConfiguration", namespace: "Microsoft.AppConfiguration" });
+ *
+ * // in each operation
+ * const span = createSpan("deleteConfigurationSetting", operationOptions);
+ *    // code...
+ * span.end();
+ * ```
+ *
+ * @hidden
+ * @param args - allows configuration of the prefix for each span as well as the az.namespace field.
+ */
+export function createSpanFunction(args) {
+    return function (operationName, operationOptions) {
+        const tracer = getTracer();
+        const tracingOptions = (operationOptions === null || operationOptions === void 0 ? void 0 : operationOptions.tracingOptions) || {};
+        const spanOptions = Object.assign({ kind: SpanKind.INTERNAL }, tracingOptions.spanOptions);
+        const spanName = args.packagePrefix ? `${args.packagePrefix}.${operationName}` : operationName;
+        let span;
+        if (isTracingDisabled()) {
+            span = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
+        }
+        else {
+            span = tracer.startSpan(spanName, spanOptions, tracingOptions.tracingContext);
+        }
+        if (args.namespace) {
+            span.setAttribute("az.namespace", args.namespace);
+        }
+        let newSpanOptions = tracingOptions.spanOptions || {};
+        if (span.isRecording() && args.namespace) {
+            newSpanOptions = Object.assign(Object.assign({}, tracingOptions.spanOptions), { attributes: Object.assign(Object.assign({}, spanOptions.attributes), { "az.namespace": args.namespace }) });
+        }
+        const newTracingOptions = Object.assign(Object.assign({}, tracingOptions), { spanOptions: newSpanOptions, tracingContext: setSpan(tracingOptions.tracingContext || otContext.active(), span) });
+        const newOperationOptions = Object.assign(Object.assign({}, operationOptions), { tracingOptions: newTracingOptions });
+        return {
+            span,
+            updatedOptions: newOperationOptions
+        };
+    };
+}
+//# sourceMappingURL=createSpan.js.map

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/dist-esm/src/index.js

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+// Tracers and wrappers
+export { createSpanFunction } from "./createSpan";
+// Shared interfaces
+export { context, getSpan, getSpanContext, getTracer, isSpanContextValid, setSpan, setSpanContext, SpanKind, SpanStatusCode } from "./interfaces";
+// Utilities
+export { extractSpanContextFromTraceParentHeader, getTraceParentHeader } from "./utils/traceParentHeader";
+//# sourceMappingURL=index.js.map

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/dist-esm/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,uBAAuB;AACvB,OAAO,EAAE,kBAAkB,EAA0B,MAAM,cAAc,CAAC;AAE1E,oBAAoB;AACpB,OAAO,EACL,OAAO,EAOP,OAAO,EACP,cAAc,EACd,SAAS,EAET,kBAAkB,EAGlB,OAAO,EACP,cAAc,EAKd,QAAQ,EAGR,cAAc,EAKf,MAAM,cAAc,CAAC;AAEtB,YAAY;AACZ,OAAO,EACL,uCAAuC,EACvC,oBAAoB,EACrB,MAAM,2BAA2B,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\n// Tracers and wrappers\nexport { createSpanFunction, CreateSpanFunctionArgs } from \"./createSpan\";\n\n// Shared interfaces\nexport {\n  context,\n  Context,\n  ContextAPI,\n  Exception,\n  ExceptionWithCode,\n  ExceptionWithMessage,\n  ExceptionWithName,\n  getSpan,\n  getSpanContext,\n  getTracer,\n  HrTime,\n  isSpanContextValid,\n  Link,\n  OperationTracingOptions,\n  setSpan,\n  setSpanContext,\n  Span,\n  SpanAttributes,\n  SpanAttributeValue,\n  SpanContext,\n  SpanKind,\n  SpanOptions,\n  SpanStatus,\n  SpanStatusCode,\n  TimeInput,\n  TraceFlags,\n  Tracer,\n  TraceState\n} from \"./interfaces\";\n\n// Utilities\nexport {\n  extractSpanContextFromTraceParentHeader,\n  getTraceParentHeader\n} from \"./utils/traceParentHeader\";\n"]}

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/dist-esm/src/interfaces.js

@@ -0,0 +1,102 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { context as otContext, trace as otTrace } from "@opentelemetry/api";
+/**
+ * The kind of span.
+ */
+export var SpanKind;
+(function (SpanKind) {
+    /** Default value. Indicates that the span is used internally. */
+    SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
+    /**
+     * Indicates that the span covers server-side handling of an RPC or other
+     * remote request.
+     */
+    SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
+    /**
+     * Indicates that the span covers the client-side wrapper around an RPC or
+     * other remote request.
+     */
+    SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
+    /**
+     * Indicates that the span describes producer sending a message to a
+     * broker. Unlike client and server, there is no direct critical path latency
+     * relationship between producer and consumer spans.
+     */
+    SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
+    /**
+     * Indicates that the span describes consumer receiving a message from a
+     * broker. Unlike client and server, there is no direct critical path latency
+     * relationship between producer and consumer spans.
+     */
+    SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
+})(SpanKind || (SpanKind = {}));
+/**
+ * Return the span if one exists
+ *
+ * @param context - context to get span from
+ */
+export function getSpan(context) {
+    return otTrace.getSpan(context);
+}
+/**
+ * Set the span on a context
+ *
+ * @param context - context to use as parent
+ * @param span - span to set active
+ */
+export function setSpan(context, span) {
+    return otTrace.setSpan(context, span);
+}
+/**
+ * Wrap span context in a NoopSpan and set as span in a new
+ * context
+ *
+ * @param context - context to set active span on
+ * @param spanContext - span context to be wrapped
+ */
+export function setSpanContext(context, spanContext) {
+    return otTrace.setSpanContext(context, spanContext);
+}
+/**
+ * Get the span context of the span if it exists.
+ *
+ * @param context - context to get values from
+ */
+export function getSpanContext(context) {
+    return otTrace.getSpanContext(context);
+}
+/**
+ * Returns true of the given {@link SpanContext} is valid.
+ * A valid {@link SpanContext} is one which has a valid trace ID and span ID as per the spec.
+ *
+ * @param context - the {@link SpanContext} to validate.
+ *
+ * @returns true if the {@link SpanContext} is valid, false otherwise.
+ */
+export function isSpanContextValid(context) {
+    return otTrace.isSpanContextValid(context);
+}
+export function getTracer(name, version) {
+    return otTrace.getTracer(name || "azure/core-tracing", version);
+}
+/** Entrypoint for context API */
+export const context = otContext;
+/** SpanStatusCode */
+export var SpanStatusCode;
+(function (SpanStatusCode) {
+    /**
+     * The default status.
+     */
+    SpanStatusCode[SpanStatusCode["UNSET"] = 0] = "UNSET";
+    /**
+     * The operation has been validated by an Application developer or
+     * Operator to have completed successfully.
+     */
+    SpanStatusCode[SpanStatusCode["OK"] = 1] = "OK";
+    /**
+     * The operation contains an error.
+     */
+    SpanStatusCode[SpanStatusCode["ERROR"] = 2] = "ERROR";
+})(SpanStatusCode || (SpanStatusCode = {}));
+//# sourceMappingURL=interfaces.js.map

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/dist-esm/src/utils/traceParentHeader.js

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+const VERSION = "00";
+/**
+ * Generates a `SpanContext` given a `traceparent` header value.
+ * @param traceParent - Serialized span context data as a `traceparent` header value.
+ * @returns The `SpanContext` generated from the `traceparent` value.
+ */
+export function extractSpanContextFromTraceParentHeader(traceParentHeader) {
+    const parts = traceParentHeader.split("-");
+    if (parts.length !== 4) {
+        return;
+    }
+    const [version, traceId, spanId, traceOptions] = parts;
+    if (version !== VERSION) {
+        return;
+    }
+    const traceFlags = parseInt(traceOptions, 16);
+    const spanContext = {
+        spanId,
+        traceId,
+        traceFlags
+    };
+    return spanContext;
+}
+/**
+ * Generates a `traceparent` value given a span context.
+ * @param spanContext - Contains context for a specific span.
+ * @returns The `spanContext` represented as a `traceparent` value.
+ */
+export function getTraceParentHeader(spanContext) {
+    const missingFields = [];
+    if (!spanContext.traceId) {
+        missingFields.push("traceId");
+    }
+    if (!spanContext.spanId) {
+        missingFields.push("spanId");
+    }
+    if (missingFields.length) {
+        return;
+    }
+    const flags = spanContext.traceFlags || 0 /* NONE */;
+    const hexFlags = flags.toString(16);
+    const traceFlags = hexFlags.length === 1 ? `0${hexFlags}` : hexFlags;
+    // https://www.w3.org/TR/trace-context/#traceparent-header-field-values
+    return `${VERSION}-${spanContext.traceId}-${spanContext.spanId}-${traceFlags}`;
+}
+//# sourceMappingURL=traceParentHeader.js.map

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/dist-esm/src/utils/traceParentHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceParentHeader.js","sourceRoot":"","sources":["../../../src/utils/traceParentHeader.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAIlC,MAAM,OAAO,GAAG,IAAI,CAAC;AAErB;;;;GAIG;AACH,MAAM,UAAU,uCAAuC,CACrD,iBAAyB;IAEzB,MAAM,KAAK,GAAG,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAE3C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;QACtB,OAAO;KACR;IAED,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,GAAG,KAAK,CAAC;IAEvD,IAAI,OAAO,KAAK,OAAO,EAAE;QACvB,OAAO;KACR;IAED,MAAM,UAAU,GAAG,QAAQ,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;IAE9C,MAAM,WAAW,GAAgB;QAC/B,MAAM;QACN,OAAO;QACP,UAAU;KACX,CAAC;IAEF,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,WAAwB;IAC3D,MAAM,aAAa,GAAa,EAAE,CAAC;IACnC,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE;QACxB,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;KAC/B;IACD,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE;QACvB,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;KAC9B;IAED,IAAI,aAAa,CAAC,MAAM,EAAE;QACxB,OAAO;KACR;IAED,MAAM,KAAK,GAAG,WAAW,CAAC,UAAU,gBAAmB,CAAC;IACxD,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IACpC,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,QAAQ,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;IAErE,uEAAuE;IACvE,OAAO,GAAG,OAAO,IAAI,WAAW,CAAC,OAAO,IAAI,WAAW,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;AACjF,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\nimport { SpanContext, TraceFlags } from \"../interfaces\";\n\nconst VERSION = \"00\";\n\n/**\n * Generates a `SpanContext` given a `traceparent` header value.\n * @param traceParent - Serialized span context data as a `traceparent` header value.\n * @returns The `SpanContext` generated from the `traceparent` value.\n */\nexport function extractSpanContextFromTraceParentHeader(\n  traceParentHeader: string\n): SpanContext | undefined {\n  const parts = traceParentHeader.split(\"-\");\n\n  if (parts.length !== 4) {\n    return;\n  }\n\n  const [version, traceId, spanId, traceOptions] = parts;\n\n  if (version !== VERSION) {\n    return;\n  }\n\n  const traceFlags = parseInt(traceOptions, 16);\n\n  const spanContext: SpanContext = {\n    spanId,\n    traceId,\n    traceFlags\n  };\n\n  return spanContext;\n}\n\n/**\n * Generates a `traceparent` value given a span context.\n * @param spanContext - Contains context for a specific span.\n * @returns The `spanContext` represented as a `traceparent` value.\n */\nexport function getTraceParentHeader(spanContext: SpanContext): string | undefined {\n  const missingFields: string[] = [];\n  if (!spanContext.traceId) {\n    missingFields.push(\"traceId\");\n  }\n  if (!spanContext.spanId) {\n    missingFields.push(\"spanId\");\n  }\n\n  if (missingFields.length) {\n    return;\n  }\n\n  const flags = spanContext.traceFlags || TraceFlags.NONE;\n  const hexFlags = flags.toString(16);\n  const traceFlags = hexFlags.length === 1 ? `0${hexFlags}` : hexFlags;\n\n  // https://www.w3.org/TR/trace-context/#traceparent-header-field-values\n  return `${VERSION}-${spanContext.traceId}-${spanContext.spanId}-${traceFlags}`;\n}\n"]}

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/dist/index.js

@@ -0,0 +1,219 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var api = require('@opentelemetry/api');
+
+// Copyright (c) Microsoft Corporation.
+(function (SpanKind) {
+    /** Default value. Indicates that the span is used internally. */
+    SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
+    /**
+     * Indicates that the span covers server-side handling of an RPC or other
+     * remote request.
+     */
+    SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
+    /**
+     * Indicates that the span covers the client-side wrapper around an RPC or
+     * other remote request.
+     */
+    SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
+    /**
+     * Indicates that the span describes producer sending a message to a
+     * broker. Unlike client and server, there is no direct critical path latency
+     * relationship between producer and consumer spans.
+     */
+    SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
+    /**
+     * Indicates that the span describes consumer receiving a message from a
+     * broker. Unlike client and server, there is no direct critical path latency
+     * relationship between producer and consumer spans.
+     */
+    SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
+})(exports.SpanKind || (exports.SpanKind = {}));
+/**
+ * Return the span if one exists
+ *
+ * @param context - context to get span from
+ */
+function getSpan(context) {
+    return api.trace.getSpan(context);
+}
+/**
+ * Set the span on a context
+ *
+ * @param context - context to use as parent
+ * @param span - span to set active
+ */
+function setSpan(context, span) {
+    return api.trace.setSpan(context, span);
+}
+/**
+ * Wrap span context in a NoopSpan and set as span in a new
+ * context
+ *
+ * @param context - context to set active span on
+ * @param spanContext - span context to be wrapped
+ */
+function setSpanContext(context, spanContext) {
+    return api.trace.setSpanContext(context, spanContext);
+}
+/**
+ * Get the span context of the span if it exists.
+ *
+ * @param context - context to get values from
+ */
+function getSpanContext(context) {
+    return api.trace.getSpanContext(context);
+}
+/**
+ * Returns true of the given {@link SpanContext} is valid.
+ * A valid {@link SpanContext} is one which has a valid trace ID and span ID as per the spec.
+ *
+ * @param context - the {@link SpanContext} to validate.
+ *
+ * @returns true if the {@link SpanContext} is valid, false otherwise.
+ */
+function isSpanContextValid(context) {
+    return api.trace.isSpanContextValid(context);
+}
+function getTracer(name, version) {
+    return api.trace.getTracer(name || "azure/core-tracing", version);
+}
+/** Entrypoint for context API */
+const context = api.context;
+(function (SpanStatusCode) {
+    /**
+     * The default status.
+     */
+    SpanStatusCode[SpanStatusCode["UNSET"] = 0] = "UNSET";
+    /**
+     * The operation has been validated by an Application developer or
+     * Operator to have completed successfully.
+     */
+    SpanStatusCode[SpanStatusCode["OK"] = 1] = "OK";
+    /**
+     * The operation contains an error.
+     */
+    SpanStatusCode[SpanStatusCode["ERROR"] = 2] = "ERROR";
+})(exports.SpanStatusCode || (exports.SpanStatusCode = {}));
+
+// Copyright (c) Microsoft Corporation.
+function isTracingDisabled() {
+    var _a;
+    if (typeof process === "undefined") {
+        // not supported in browser for now without polyfills
+        return false;
+    }
+    const azureTracingDisabledValue = (_a = process.env.AZURE_TRACING_DISABLED) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (azureTracingDisabledValue === "false" || azureTracingDisabledValue === "0") {
+        return false;
+    }
+    return Boolean(azureTracingDisabledValue);
+}
+/**
+ * Creates a function that can be used to create spans using the global tracer.
+ *
+ * Usage:
+ *
+ * ```typescript
+ * // once
+ * const createSpan = createSpanFunction({ packagePrefix: "Azure.Data.AppConfiguration", namespace: "Microsoft.AppConfiguration" });
+ *
+ * // in each operation
+ * const span = createSpan("deleteConfigurationSetting", operationOptions);
+ *    // code...
+ * span.end();
+ * ```
+ *
+ * @hidden
+ * @param args - allows configuration of the prefix for each span as well as the az.namespace field.
+ */
+function createSpanFunction(args) {
+    return function (operationName, operationOptions) {
+        const tracer = getTracer();
+        const tracingOptions = (operationOptions === null || operationOptions === void 0 ? void 0 : operationOptions.tracingOptions) || {};
+        const spanOptions = Object.assign({ kind: exports.SpanKind.INTERNAL }, tracingOptions.spanOptions);
+        const spanName = args.packagePrefix ? `${args.packagePrefix}.${operationName}` : operationName;
+        let span;
+        if (isTracingDisabled()) {
+            span = api.trace.wrapSpanContext(api.INVALID_SPAN_CONTEXT);
+        }
+        else {
+            span = tracer.startSpan(spanName, spanOptions, tracingOptions.tracingContext);
+        }
+        if (args.namespace) {
+            span.setAttribute("az.namespace", args.namespace);
+        }
+        let newSpanOptions = tracingOptions.spanOptions || {};
+        if (span.isRecording() && args.namespace) {
+            newSpanOptions = Object.assign(Object.assign({}, tracingOptions.spanOptions), { attributes: Object.assign(Object.assign({}, spanOptions.attributes), { "az.namespace": args.namespace }) });
+        }
+        const newTracingOptions = Object.assign(Object.assign({}, tracingOptions), { spanOptions: newSpanOptions, tracingContext: setSpan(tracingOptions.tracingContext || context.active(), span) });
+        const newOperationOptions = Object.assign(Object.assign({}, operationOptions), { tracingOptions: newTracingOptions });
+        return {
+            span,
+            updatedOptions: newOperationOptions
+        };
+    };
+}
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+const VERSION = "00";
+/**
+ * Generates a `SpanContext` given a `traceparent` header value.
+ * @param traceParent - Serialized span context data as a `traceparent` header value.
+ * @returns The `SpanContext` generated from the `traceparent` value.
+ */
+function extractSpanContextFromTraceParentHeader(traceParentHeader) {
+    const parts = traceParentHeader.split("-");
+    if (parts.length !== 4) {
+        return;
+    }
+    const [version, traceId, spanId, traceOptions] = parts;
+    if (version !== VERSION) {
+        return;
+    }
+    const traceFlags = parseInt(traceOptions, 16);
+    const spanContext = {
+        spanId,
+        traceId,
+        traceFlags
+    };
+    return spanContext;
+}
+/**
+ * Generates a `traceparent` value given a span context.
+ * @param spanContext - Contains context for a specific span.
+ * @returns The `spanContext` represented as a `traceparent` value.
+ */
+function getTraceParentHeader(spanContext) {
+    const missingFields = [];
+    if (!spanContext.traceId) {
+        missingFields.push("traceId");
+    }
+    if (!spanContext.spanId) {
+        missingFields.push("spanId");
+    }
+    if (missingFields.length) {
+        return;
+    }
+    const flags = spanContext.traceFlags || 0 /* NONE */;
+    const hexFlags = flags.toString(16);
+    const traceFlags = hexFlags.length === 1 ? `0${hexFlags}` : hexFlags;
+    // https://www.w3.org/TR/trace-context/#traceparent-header-field-values
+    return `${VERSION}-${spanContext.traceId}-${spanContext.spanId}-${traceFlags}`;
+}
+
+exports.context = context;
+exports.createSpanFunction = createSpanFunction;
+exports.extractSpanContextFromTraceParentHeader = extractSpanContextFromTraceParentHeader;
+exports.getSpan = getSpan;
+exports.getSpanContext = getSpanContext;
+exports.getTraceParentHeader = getTraceParentHeader;
+exports.getTracer = getTracer;
+exports.isSpanContextValid = isSpanContextValid;
+exports.setSpan = setSpan;
+exports.setSpanContext = setSpanContext;
+//# sourceMappingURL=index.js.map

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@azure/core-tracing",
+  "version": "1.0.0-preview.13",
+  "description": "Provides low-level interfaces and helper methods for tracing in Azure SDK",
+  "sdk-type": "client",
+  "main": "dist/index.js",
+  "module": "dist-esm/src/index.js",
+  "browser": {
+    "./dist-esm/src/utils/global.js": "./dist-esm/src/utils/global.browser.js"
+  },
+  "types": "types/core-tracing.d.ts",
+  "scripts": {
+    "audit": "node ../../../common/scripts/rush-audit.js && rimraf node_modules package-lock.json && npm i --package-lock-only 2>&1 && npm audit",
+    "build:samples": "echo Obsolete",
+    "build:test": "tsc -p . && rollup -c 2>&1",
+    "build": "tsc -p . && rollup -c 2>&1 && api-extractor run --local",
+    "check-format": "prettier --list-different --config ../../../.prettierrc.json --ignore-path ../../../.prettierignore \"src/**/*.ts\" \"test/**/*.ts\" \"*.{js,json}\"",
+    "clean": "rimraf dist dist-* temp types *.tgz *.log",
+    "docs": "typedoc --excludePrivate --excludeNotExported --excludeExternals --stripInternal --mode file --out ./dist/docs ./src",
+    "execute:samples": "echo skipped",
+    "extract-api": "tsc -p . && api-extractor run --local",
+    "format": "prettier --write --config ../../../.prettierrc.json --ignore-path ../../../.prettierignore \"src/**/*.ts\" \"test/**/*.ts\" \"samples-dev/**/*.ts\" \"*.{js,json}\"",
+    "integration-test:browser": "echo skipped",
+    "integration-test:node": "echo skipped",
+    "integration-test": "npm run integration-test:node && npm run integration-test:browser",
+    "lint:fix": "eslint package.json api-extractor.json src test --ext .ts --fix --fix-type [problem,suggestion]",
+    "lint": "eslint package.json api-extractor.json src test --ext .ts",
+    "pack": "npm pack 2>&1",
+    "prebuild": "npm run clean",
+    "test:browser": "npm run clean && npm run build:test && npm run unit-test:browser && npm run integration-test:browser",
+    "test:node": "npm run clean && tsc -p . && npm run unit-test:node && npm run integration-test:node",
+    "test": "npm run clean && tsc -p . && npm run unit-test:node && rollup -c 2>&1 && npm run unit-test:browser && npm run integration-test",
+    "unit-test:browser": "karma start --single-run",
+    "unit-test:node": "mocha -r esm -r ts-node/register --reporter ../../../common/tools/mocha-multi-reporter.js --timeout 1200000 --full-trace  --exclude \"test/**/browser/*.spec.ts\" \"test/**/*.spec.ts\"",
+    "unit-test": "npm run unit-test:node && npm run unit-test:browser"
+  },
+  "files": [
+    "dist/",
+    "dist-esm/src/",
+    "types/core-tracing.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": "github:Azure/azure-sdk-for-js",
+  "keywords": [
+    "azure",
+    "tracing",
+    "cloud"
+  ],
+  "author": "Microsoft Corporation",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Azure/azure-sdk-for-js/issues"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "homepage": "https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/core/core-tracing/README.md",
+  "sideEffects": false,
+  "dependencies": {
+    "@opentelemetry/api": "^1.0.1",
+    "tslib": "^2.2.0"
+  },
+  "devDependencies": {
+    "@azure/core-auth": "^1.3.0",
+    "@azure/dev-tool": "^1.0.0",
+    "@azure/eslint-plugin-azure-sdk": "^3.0.0",
+    "@microsoft/api-extractor": "7.7.11",
+    "@opentelemetry/tracing": "^0.22.0",
+    "@types/chai": "^4.1.6",
+    "@types/mocha": "^7.0.2",
+    "@types/node": "^12.0.0",
+    "chai": "^4.2.0",
+    "cross-env": "^7.0.2",
+    "eslint": "^7.15.0",
+    "inherits": "^2.0.3",
+    "karma": "^6.2.0",
+    "karma-chrome-launcher": "^3.0.0",
+    "karma-coverage": "^2.0.0",
+    "karma-edge-launcher": "^0.4.2",
+    "karma-env-preprocessor": "^0.1.1",
+    "karma-firefox-launcher": "^1.1.0",
+    "karma-ie-launcher": "^1.0.0",
+    "karma-junit-reporter": "^2.0.1",
+    "karma-mocha": "^2.0.1",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-sourcemap-loader": "^0.3.8",
+    "mocha": "^7.1.1",
+    "mocha-junit-reporter": "^1.18.0",
+    "prettier": "^1.16.4",
+    "rimraf": "^3.0.0",
+    "rollup": "^1.16.3",
+    "typescript": "~4.2.0",
+    "util": "^0.12.1",
+    "typedoc": "0.15.2",
+    "sinon": "^9.0.2",
+    "@types/sinon": "^9.0.4"
+  }
+}

dawidd6/action-download-artifact-v3/node_modules/@azure/core-tracing/types/core-tracing.d.ts

@@ -0,0 +1,531 @@
+
+/**
+ * OpenTelemetry compatible interface for Context
+ */
+export declare interface Context {
+    /**
+     * Get a value from the context.
+     *
+     * @param key - key which identifies a context value
+     */
+    getValue(key: symbol): unknown;
+    /**
+     * Create a new context which inherits from this context and has
+     * the given key set to the given value.
+     *
+     * @param key - context key for which to set the value
+     * @param value - value to set for the given key
+     */
+    setValue(key: symbol, value: unknown): Context;
+    /**
+     * Return a new context which inherits from this context but does
+     * not contain a value for the given key.
+     *
+     * @param key - context key for which to clear a value
+     */
+    deleteValue(key: symbol): Context;
+}
+
+/** Entrypoint for context API */
+export declare const context: ContextAPI;
+
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Context API
+ */
+export declare interface ContextAPI {
+    /**
+     * Get the currently active context
+     */
+    active(): Context;
+}
+
+/**
+ * Creates a function that can be used to create spans using the global tracer.
+ *
+ * Usage:
+ *
+ * ```typescript
+ * // once
+ * const createSpan = createSpanFunction({ packagePrefix: "Azure.Data.AppConfiguration", namespace: "Microsoft.AppConfiguration" });
+ *
+ * // in each operation
+ * const span = createSpan("deleteConfigurationSetting", operationOptions);
+ *    // code...
+ * span.end();
+ * ```
+ *
+ * @hidden
+ * @param args - allows configuration of the prefix for each span as well as the az.namespace field.
+ */
+export declare function createSpanFunction(args: CreateSpanFunctionArgs): <T extends {
+    tracingOptions?: OperationTracingOptions | undefined;
+}>(operationName: string, operationOptions: T | undefined) => {
+    span: Span;
+    updatedOptions: T;
+};
+
+/**
+ * Arguments for `createSpanFunction` that allow you to specify the
+ * prefix for each created span as well as the `az.namespace` attribute.
+ *
+ * @hidden
+ */
+export declare interface CreateSpanFunctionArgs {
+    /**
+     * Package name prefix.
+     *
+     * NOTE: if this is empty no prefix will be applied to created Span names.
+     */
+    packagePrefix: string;
+    /**
+     * Service namespace
+     *
+     * NOTE: if this is empty no `az.namespace` attribute will be added to created Spans.
+     */
+    namespace: string;
+}
+
+/**
+ * An Exception for a Span.
+ */
+export declare type Exception = ExceptionWithCode | ExceptionWithMessage | ExceptionWithName | string;
+
+/**
+ * An Exception with a code.
+ */
+export declare interface ExceptionWithCode {
+    /** The code. */
+    code: string | number;
+    /** The name. */
+    name?: string;
+    /** The message. */
+    message?: string;
+    /** The stack. */
+    stack?: string;
+}
+
+/**
+ * An Exception with a message.
+ */
+export declare interface ExceptionWithMessage {
+    /** The code. */
+    code?: string | number;
+    /** The message. */
+    message: string;
+    /** The name. */
+    name?: string;
+    /** The stack. */
+    stack?: string;
+}
+
+/**
+ * An Exception with a name.
+ */
+export declare interface ExceptionWithName {
+    /** The code. */
+    code?: string | number;
+    /** The message. */
+    message?: string;
+    /** The name. */
+    name: string;
+    /** The stack. */
+    stack?: string;
+}
+
+/**
+ * Generates a `SpanContext` given a `traceparent` header value.
+ * @param traceParent - Serialized span context data as a `traceparent` header value.
+ * @returns The `SpanContext` generated from the `traceparent` value.
+ */
+export declare function extractSpanContextFromTraceParentHeader(traceParentHeader: string): SpanContext | undefined;
+
+/**
+ * Return the span if one exists
+ *
+ * @param context - context to get span from
+ */
+export declare function getSpan(context: Context): Span | undefined;
+
+/**
+ * Get the span context of the span if it exists.
+ *
+ * @param context - context to get values from
+ */
+export declare function getSpanContext(context: Context): SpanContext | undefined;
+
+/**
+ * Generates a `traceparent` value given a span context.
+ * @param spanContext - Contains context for a specific span.
+ * @returns The `spanContext` represented as a `traceparent` value.
+ */
+export declare function getTraceParentHeader(spanContext: SpanContext): string | undefined;
+
+/**
+ * Retrieves a tracer from the global tracer provider.
+ */
+export declare function getTracer(): Tracer;
+
+/**
+ * Retrieves a tracer from the global tracer provider.
+ */
+export declare function getTracer(name: string, version?: string): Tracer;
+
+/**
+ * Represents high resolution time.
+ */
+export declare type HrTime = [number, number];
+
+/**
+ * Returns true of the given {@link SpanContext} is valid.
+ * A valid {@link SpanContext} is one which has a valid trace ID and span ID as per the spec.
+ *
+ * @param context - the {@link SpanContext} to validate.
+ *
+ * @returns true if the {@link SpanContext} is valid, false otherwise.
+ */
+export declare function isSpanContextValid(context: SpanContext): boolean;
+
+/**
+ * Used to specify a span that is linked to another.
+ */
+export declare interface Link {
+    /** The {@link SpanContext} of a linked span. */
+    context: SpanContext;
+    /** A set of {@link SpanAttributes} on the link. */
+    attributes?: SpanAttributes;
+}
+
+/**
+ * Tracing options to set on an operation.
+ */
+export declare interface OperationTracingOptions {
+    /**
+     * OpenTelemetry SpanOptions used to create a span when tracing is enabled.
+     */
+    spanOptions?: SpanOptions;
+    /**
+     * OpenTelemetry context to use for created Spans.
+     */
+    tracingContext?: Context;
+}
+
+/**
+ * Set the span on a context
+ *
+ * @param context - context to use as parent
+ * @param span - span to set active
+ */
+export declare function setSpan(context: Context, span: Span): Context;
+
+/**
+ * Wrap span context in a NoopSpan and set as span in a new
+ * context
+ *
+ * @param context - context to set active span on
+ * @param spanContext - span context to be wrapped
+ */
+export declare function setSpanContext(context: Context, spanContext: SpanContext): Context;
+
+/**
+ * An interface that represents a span. A span represents a single operation
+ * within a trace. Examples of span might include remote procedure calls or a
+ * in-process function calls to sub-components. A Trace has a single, top-level
+ * "root" Span that in turn may have zero or more child Spans, which in turn
+ * may have children.
+ *
+ * Spans are created by the {@link Tracer.startSpan} method.
+ */
+export declare interface Span {
+    /**
+     * Returns the {@link SpanContext} object associated with this Span.
+     *
+     * Get an immutable, serializable identifier for this span that can be used
+     * to create new child spans. Returned SpanContext is usable even after the
+     * span ends.
+     *
+     * @returns the SpanContext object associated with this Span.
+     */
+    spanContext(): SpanContext;
+    /**
+     * Sets an attribute to the span.
+     *
+     * Sets a single Attribute with the key and value passed as arguments.
+     *
+     * @param key - the key for this attribute.
+     * @param value - the value for this attribute. Setting a value null or
+     *              undefined is invalid and will result in undefined behavior.
+     */
+    setAttribute(key: string, value: SpanAttributeValue): this;
+    /**
+     * Sets attributes to the span.
+     *
+     * @param attributes - the attributes that will be added.
+     *                   null or undefined attribute values
+     *                   are invalid and will result in undefined behavior.
+     */
+    setAttributes(attributes: SpanAttributes): this;
+    /**
+     * Adds an event to the Span.
+     *
+     * @param name - the name of the event.
+     * @param attributesOrStartTime -  the attributes that will be added; these are
+     *     associated with this event. Can be also a start time
+     *     if type is TimeInput and 3rd param is undefined
+     * @param startTime - start time of the event.
+     */
+    addEvent(name: string, attributesOrStartTime?: SpanAttributes | TimeInput, startTime?: TimeInput): this;
+    /**
+     * Sets a status to the span. If used, this will override the default Span
+     * status. Default is {@link SpanStatusCode.UNSET}. SetStatus overrides the value
+     * of previous calls to SetStatus on the Span.
+     *
+     * @param status - the SpanStatus to set.
+     */
+    setStatus(status: SpanStatus): this;
+    /**
+     * Marks the end of Span execution.
+     *
+     * Call to End of a Span MUST not have any effects on child spans. Those may
+     * still be running and can be ended later.
+     *
+     * Do not return `this`. The Span generally should not be used after it
+     * is ended so chaining is not desired in this context.
+     *
+     * @param endTime - the time to set as Span's end time. If not provided,
+     *     use the current time as the span's end time.
+     */
+    end(endTime?: TimeInput): void;
+    /**
+     * Returns the flag whether this span will be recorded.
+     *
+     * @returns true if this Span is active and recording information like events
+     *     with the `AddEvent` operation and attributes using `setAttributes`.
+     */
+    isRecording(): boolean;
+    /**
+     * Sets exception as a span event
+     * @param exception - the exception the only accepted values are string or Error
+     * @param time - the time to set as Span's event time. If not provided,
+     *     use the current time.
+     */
+    recordException(exception: Exception, time?: TimeInput): void;
+    /**
+     * Updates the Span name.
+     *
+     * This will override the name provided via {@link Tracer.startSpan}.
+     *
+     * Upon this update, any sampling behavior based on Span name will depend on
+     * the implementation.
+     *
+     * @param name - the Span name.
+     */
+    updateName(name: string): this;
+}
+
+/**
+ * Attributes for a Span.
+ */
+export declare interface SpanAttributes {
+    /**
+     * Attributes for a Span.
+     */
+    [attributeKey: string]: SpanAttributeValue | undefined;
+}
+
+/**
+ * Attribute values may be any non-nullish primitive value except an object.
+ *
+ * null or undefined attribute values are invalid and will result in undefined behavior.
+ */
+export declare type SpanAttributeValue = string | number | boolean | Array<null | undefined | string> | Array<null | undefined | number> | Array<null | undefined | boolean>;
+
+/**
+ * A light interface that tries to be structurally compatible with OpenTelemetry
+ */
+export declare interface SpanContext {
+    /**
+     * UUID of a trace.
+     */
+    traceId: string;
+    /**
+     * UUID of a Span.
+     */
+    spanId: string;
+    /**
+     * https://www.w3.org/TR/trace-context/#trace-flags
+     */
+    traceFlags: number;
+    /**
+     * Tracing-system-specific info to propagate.
+     *
+     * The tracestate field value is a `list` as defined below. The `list` is a
+     * series of `list-members` separated by commas `,`, and a list-member is a
+     * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
+     * surrounding `list-members` are ignored. There can be a maximum of 32
+     * `list-members` in a `list`.
+     * More Info: https://www.w3.org/TR/trace-context/#tracestate-field
+     *
+     * Examples:
+     *     Single tracing system (generic format):
+     *         tracestate: rojo=00f067aa0ba902b7
+     *     Multiple tracing systems (with different formatting):
+     *         tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE
+     */
+    traceState?: TraceState;
+}
+
+/**
+ * The kind of span.
+ */
+export declare enum SpanKind {
+    /** Default value. Indicates that the span is used internally. */
+    INTERNAL = 0,
+    /**
+     * Indicates that the span covers server-side handling of an RPC or other
+     * remote request.
+     */
+    SERVER = 1,
+    /**
+     * Indicates that the span covers the client-side wrapper around an RPC or
+     * other remote request.
+     */
+    CLIENT = 2,
+    /**
+     * Indicates that the span describes producer sending a message to a
+     * broker. Unlike client and server, there is no direct critical path latency
+     * relationship between producer and consumer spans.
+     */
+    PRODUCER = 3,
+    /**
+     * Indicates that the span describes consumer receiving a message from a
+     * broker. Unlike client and server, there is no direct critical path latency
+     * relationship between producer and consumer spans.
+     */
+    CONSUMER = 4
+}
+
+/**
+ * An interface that enables manual propagation of Spans
+ */
+export declare interface SpanOptions {
+    /**
+     * Attributes to set on the Span
+     */
+    attributes?: SpanAttributes;
+    /** {@link Link}s span to other spans */
+    links?: Link[];
+    /**
+     * The type of Span. Default to SpanKind.INTERNAL
+     */
+    kind?: SpanKind;
+    /**
+     * A manually specified start time for the created `Span` object.
+     */
+    startTime?: TimeInput;
+}
+
+/**
+ * The status for a span.
+ */
+export declare interface SpanStatus {
+    /** The status code of this message. */
+    code: SpanStatusCode;
+    /** A developer-facing error message. */
+    message?: string;
+}
+
+/** SpanStatusCode */
+export declare enum SpanStatusCode {
+    /**
+     * The default status.
+     */
+    UNSET = 0,
+    /**
+     * The operation has been validated by an Application developer or
+     * Operator to have completed successfully.
+     */
+    OK = 1,
+    /**
+     * The operation contains an error.
+     */
+    ERROR = 2
+}
+
+/**
+ * Used to represent a Time.
+ */
+export declare type TimeInput = HrTime | number | Date;
+
+/**
+ * Shorthand enum for common traceFlags values inside SpanContext
+ */
+export declare const enum TraceFlags {
+    /** No flag set. */
+    NONE = 0,
+    /** Caller is collecting trace information. */
+    SAMPLED = 1
+}
+
+/**
+ * A Tracer.
+ */
+export declare interface Tracer {
+    /**
+     * Starts a new {@link Span}. Start the span without setting it on context.
+     *
+     * This method does NOT modify the current Context.
+     *
+     * @param name - The name of the span
+     * @param options - SpanOptions used for span creation
+     * @param context - Context to use to extract parent
+     * @returns The newly created span
+     * @example
+     *     const span = tracer.startSpan('op');
+     *     span.setAttribute('key', 'value');
+     *     span.end();
+     */
+    startSpan(name: string, options?: SpanOptions, context?: Context): Span;
+}
+
+/**
+ * TraceState.
+ */
+export declare interface TraceState {
+    /**
+     * Create a new TraceState which inherits from this TraceState and has the
+     * given key set.
+     * The new entry will always be added in the front of the list of states.
+     *
+     * @param key - key of the TraceState entry.
+     * @param value - value of the TraceState entry.
+     */
+    set(key: string, value: string): TraceState;
+    /**
+     * Return a new TraceState which inherits from this TraceState but does not
+     * contain the given key.
+     *
+     * @param key - the key for the TraceState entry to be removed.
+     */
+    unset(key: string): TraceState;
+    /**
+     * Returns the value to which the specified key is mapped, or `undefined` if
+     * this map contains no mapping for the key.
+     *
+     * @param key - with which the specified value is to be associated.
+     * @returns the value to which the specified key is mapped, or `undefined` if
+     *     this map contains no mapping for the key.
+     */
+    get(key: string): string | undefined;
+    /**
+     * Serializes the TraceState to a `list` as defined below. The `list` is a
+     * series of `list-members` separated by commas `,`, and a list-member is a
+     * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
+     * surrounding `list-members` are ignored. There can be a maximum of 32
+     * `list-members` in a `list`.
+     *
+     * @returns the serialized string.
+     */
+    serialize(): string;
+}
+
+export { }