@typespec/ts-http-runtime 1.0.0-alpha.20240214.1 → 1.0.0-alpha.20240223.2

package/dist/esm/retryStrategies/exponentialRetryStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialRetryStrategy.js","sourceRoot":"","sources":["../../../src/retryStrategies/exponentialRetryStrategy.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAIlC,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAEzE,gCAAgC;AAChC,MAAM,6BAA6B,GAAG,IAAI,CAAC;AAC3C,MAAM,iCAAiC,GAAG,IAAI,GAAG,EAAE,CAAC;AAEpD;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CACtC,UAuBI,EAAE;IAEN,MAAM,aAAa,GAAG,OAAO,CAAC,cAAc,IAAI,6BAA6B,CAAC;IAC9E,MAAM,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,IAAI,iCAAiC,CAAC;IAExF,IAAI,cAAc,GAAG,aAAa,CAAC;IAEnC,OAAO;QACL,IAAI,EAAE,0BAA0B;QAChC,KAAK,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,EAAE;YAC3C,MAAM,kBAAkB,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;YACxD,MAAM,kBAAkB,GAAG,kBAAkB,IAAI,OAAO,CAAC,kBAAkB,CAAC;YAE5E,MAAM,aAAa,GAAG,0BAA0B,CAAC,QAAQ,CAAC,CAAC;YAC3D,MAAM,yBAAyB,GAAG,aAAa,IAAI,OAAO,CAAC,qBAAqB,CAAC;YACjF,MAAM,eAAe,GAAG,QAAQ,IAAI,CAAC,yBAAyB,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAE5F,IAAI,eAAe,IAAI,yBAAyB,IAAI,kBAAkB,EAAE,CAAC;gBACvE,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;YAChC,CAAC;YAED,IAAI,aAAa,IAAI,CAAC,kBAAkB,IAAI,CAAC,aAAa,EAAE,CAAC;gBAC3D,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,CAAC;YACzC,CAAC;YAED,6CAA6C;YAC7C,MAAM,gBAAgB,GAAG,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;YAClE,yCAAyC;YACzC,MAAM,uBAAuB,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;YAC7E,gFAAgF;YAChF,mEAAmE;YACnE,cAAc;gBACZ,uBAAuB,GAAG,CAAC,GAAG,yBAAyB,CAAC,CAAC,EAAE,uBAAuB,GAAG,CAAC,CAAC,CAAC;YAC1F,OAAO,EAAE,cAAc,EAAE,CAAC;QAC5B,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,0BAA0B,CAAC,QAA2B;IACpE,OAAO,OAAO,CACZ,QAAQ;QACN,QAAQ,CAAC,MAAM,KAAK,SAAS;QAC7B,CAAC,QAAQ,CAAC,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,CAAC;QACnD,QAAQ,CAAC,MAAM,KAAK,GAAG;QACvB,QAAQ,CAAC,MAAM,KAAK,GAAG,CAC1B,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,GAAe;IAC3C,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,CACL,GAAG,CAAC,IAAI,KAAK,WAAW;QACxB,GAAG,CAAC,IAAI,KAAK,iBAAiB;QAC9B,GAAG,CAAC,IAAI,KAAK,cAAc;QAC3B,GAAG,CAAC,IAAI,KAAK,YAAY;QACzB,GAAG,CAAC,IAAI,KAAK,QAAQ;QACrB,GAAG,CAAC,IAAI,KAAK,WAAW,CACzB,CAAC;AACJ,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\nimport { PipelineResponse } from \"../interfaces.js\";\nimport { RestError } from \"../restError.js\";\nimport { getRandomIntegerInclusive } from \"../util/random.js\";\nimport { RetryStrategy } from \"./retryStrategy.js\";\nimport { isThrottlingRetryResponse } from \"./throttlingRetryStrategy.js\";\n\n// intervals are in milliseconds\nconst DEFAULT_CLIENT_RETRY_INTERVAL = 1000;\nconst DEFAULT_CLIENT_MAX_RETRY_INTERVAL = 1000 * 64;\n\n/**\n * A retry strategy that retries with an exponentially increasing delay in these two cases:\n * - When there are errors in the underlying transport layer (e.g. DNS lookup failures).\n * - Or otherwise if the outgoing request fails (408, greater or equal than 500, except for 501 and 505).\n */\nexport function exponentialRetryStrategy(\n  options: {\n    /**\n     * The amount of delay in milliseconds between retry attempts. Defaults to 1000\n     * (1 second.) The delay increases exponentially with each retry up to a maximum\n     * specified by maxRetryDelayInMs.\n     */\n    retryDelayInMs?: number;\n\n    /**\n     * The maximum delay in milliseconds allowed before retrying an operation. Defaults\n     * to 64000 (64 seconds).\n     */\n    maxRetryDelayInMs?: number;\n\n    /**\n     * If true it won't retry if it received a system error.\n     */\n    ignoreSystemErrors?: boolean;\n\n    /**\n     * If true it won't retry if it received a non-fatal HTTP status code.\n     */\n    ignoreHttpStatusCodes?: boolean;\n  } = {},\n): RetryStrategy {\n  const retryInterval = options.retryDelayInMs ?? DEFAULT_CLIENT_RETRY_INTERVAL;\n  const maxRetryInterval = options.maxRetryDelayInMs ?? DEFAULT_CLIENT_MAX_RETRY_INTERVAL;\n\n  let retryAfterInMs = retryInterval;\n\n  return {\n    name: \"exponentialRetryStrategy\",\n    retry({ retryCount, response, responseError }) {\n      const matchedSystemError = isSystemError(responseError);\n      const ignoreSystemErrors = matchedSystemError && options.ignoreSystemErrors;\n\n      const isExponential = isExponentialRetryResponse(response);\n      const ignoreExponentialResponse = isExponential && options.ignoreHttpStatusCodes;\n      const unknownResponse = response && (isThrottlingRetryResponse(response) || !isExponential);\n\n      if (unknownResponse || ignoreExponentialResponse || ignoreSystemErrors) {\n        return { skipStrategy: true };\n      }\n\n      if (responseError && !matchedSystemError && !isExponential) {\n        return { errorToThrow: responseError };\n      }\n\n      // Exponentially increase the delay each time\n      const exponentialDelay = retryAfterInMs * Math.pow(2, retryCount);\n      // Don't let the delay exceed the maximum\n      const clampedExponentialDelay = Math.min(maxRetryInterval, exponentialDelay);\n      // Allow the final value to have some \"jitter\" (within 50% of the delay size) so\n      // that retries across multiple clients don't occur simultaneously.\n      retryAfterInMs =\n        clampedExponentialDelay / 2 + getRandomIntegerInclusive(0, clampedExponentialDelay / 2);\n      return { retryAfterInMs };\n    },\n  };\n}\n\n/**\n * A response is a retry response if it has status codes:\n * - 408, or\n * - Greater or equal than 500, except for 501 and 505.\n */\nexport function isExponentialRetryResponse(response?: PipelineResponse): boolean {\n  return Boolean(\n    response &&\n      response.status !== undefined &&\n      (response.status >= 500 || response.status === 408) &&\n      response.status !== 501 &&\n      response.status !== 505,\n  );\n}\n\n/**\n * Determines whether an error from a pipeline response was triggered in the network layer.\n */\nexport function isSystemError(err?: RestError): boolean {\n  if (!err) {\n    return false;\n  }\n  return (\n    err.code === \"ETIMEDOUT\" ||\n    err.code === \"ESOCKETTIMEDOUT\" ||\n    err.code === \"ECONNREFUSED\" ||\n    err.code === \"ECONNRESET\" ||\n    err.code === \"ENOENT\" ||\n    err.code === \"ENOTFOUND\"\n  );\n}\n"]}

package/dist/esm/retryStrategies/retryStrategy.d.ts

@@ -0,0 +1,61 @@
+import { TypeSpecRuntimeLogger } from "../logger/logger.js";
+import { PipelineResponse } from "../interfaces.js";
+import { RestError } from "../restError.js";
+/**
+ * Information provided to the retry strategy about the current progress of the retry policy.
+ */
+export interface RetryInformation {
+    /**
+     * A {@link PipelineResponse}, if the last retry attempt succeeded.
+     */
+    response?: PipelineResponse;
+    /**
+     * A {@link RestError}, if the last retry attempt failed.
+     */
+    responseError?: RestError;
+    /**
+     * Total number of retries so far.
+     */
+    retryCount: number;
+}
+/**
+ * Properties that can modify the behavior of the retry policy.
+ */
+export interface RetryModifiers {
+    /**
+     * If true, allows skipping the current strategy from running on the retry policy.
+     */
+    skipStrategy?: boolean;
+    /**
+     * Indicates to retry against this URL.
+     */
+    redirectTo?: string;
+    /**
+     * Controls whether to retry in a given number of milliseconds.
+     * If provided, a new retry will be attempted.
+     */
+    retryAfterInMs?: number;
+    /**
+     * Indicates to throw this error instead of retrying.
+     */
+    errorToThrow?: RestError;
+}
+/**
+ * A retry strategy is intended to define whether to retry or not, and how to retry.
+ */
+export interface RetryStrategy {
+    /**
+     * Name of the retry strategy. Used for logging.
+     */
+    name: string;
+    /**
+     * Logger. If it's not provided, a default logger for all retry strategies is used.
+     */
+    logger?: TypeSpecRuntimeLogger;
+    /**
+     * Function that determines how to proceed with the subsequent requests.
+     * @param state - Retry state
+     */
+    retry(state: RetryInformation): RetryModifiers;
+}
+//# sourceMappingURL=retryStrategy.d.ts.map

package/dist/esm/retryStrategies/retryStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retryStrategy.d.ts","sourceRoot":"","sources":["../../../src/retryStrategies/retryStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B;;OAEG;IACH,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,gBAAgB,GAAG,cAAc,CAAC;CAChD"}

package/dist/esm/retryStrategies/retryStrategy.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+export {};
+//# sourceMappingURL=retryStrategy.js.map

package/dist/esm/retryStrategies/retryStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retryStrategy.js","sourceRoot":"","sources":["../../../src/retryStrategies/retryStrategy.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\nimport { TypeSpecRuntimeLogger } from \"../logger/logger.js\";\nimport { PipelineResponse } from \"../interfaces.js\";\nimport { RestError } from \"../restError.js\";\n\n/**\n * Information provided to the retry strategy about the current progress of the retry policy.\n */\nexport interface RetryInformation {\n  /**\n   * A {@link PipelineResponse}, if the last retry attempt succeeded.\n   */\n  response?: PipelineResponse;\n  /**\n   * A {@link RestError}, if the last retry attempt failed.\n   */\n  responseError?: RestError;\n  /**\n   * Total number of retries so far.\n   */\n  retryCount: number;\n}\n\n/**\n * Properties that can modify the behavior of the retry policy.\n */\nexport interface RetryModifiers {\n  /**\n   * If true, allows skipping the current strategy from running on the retry policy.\n   */\n  skipStrategy?: boolean;\n  /**\n   * Indicates to retry against this URL.\n   */\n  redirectTo?: string;\n  /**\n   * Controls whether to retry in a given number of milliseconds.\n   * If provided, a new retry will be attempted.\n   */\n  retryAfterInMs?: number;\n  /**\n   * Indicates to throw this error instead of retrying.\n   */\n  errorToThrow?: RestError;\n}\n\n/**\n * A retry strategy is intended to define whether to retry or not, and how to retry.\n */\nexport interface RetryStrategy {\n  /**\n   * Name of the retry strategy. Used for logging.\n   */\n  name: string;\n  /**\n   * Logger. If it's not provided, a default logger for all retry strategies is used.\n   */\n  logger?: TypeSpecRuntimeLogger;\n  /**\n   * Function that determines how to proceed with the subsequent requests.\n   * @param state - Retry state\n   */\n  retry(state: RetryInformation): RetryModifiers;\n}\n"]}

package/dist/esm/retryStrategies/throttlingRetryStrategy.d.ts

@@ -0,0 +1,9 @@
+import { PipelineResponse } from "../index.js";
+import { RetryStrategy } from "./retryStrategy.js";
+/**
+ * A response is a retry response if it has a throttling status code (429 or 503),
+ * as long as one of the [ "Retry-After" or "retry-after-ms" or "x-ms-retry-after-ms" ] headers has a valid value.
+ */
+export declare function isThrottlingRetryResponse(response?: PipelineResponse): boolean;
+export declare function throttlingRetryStrategy(): RetryStrategy;
+//# sourceMappingURL=throttlingRetryStrategy.d.ts.map

package/dist/esm/retryStrategies/throttlingRetryStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttlingRetryStrategy.d.ts","sourceRoot":"","sources":["../../../src/retryStrategies/throttlingRetryStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAoDnD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAE9E;AAED,wBAAgB,uBAAuB,IAAI,aAAa,CAavD"}

package/dist/esm/retryStrategies/throttlingRetryStrategy.js

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { parseHeaderValueAsNumber } from "../util/helpers.js";
+/**
+ * The header that comes back from services representing
+ * the amount of time (minimum) to wait to retry (in seconds or timestamp after which we can retry).
+ */
+const RetryAfterHeader = "Retry-After";
+/**
+ * The headers that come back from services representing
+ * the amount of time (minimum) to wait to retry.
+ *
+ * "retry-after-ms", "x-ms-retry-after-ms" : milliseconds
+ * "Retry-After" : seconds or timestamp
+ */
+const AllRetryAfterHeaders = ["retry-after-ms", "x-ms-retry-after-ms", RetryAfterHeader];
+/**
+ * A response is a throttling retry response if it has a throttling status code (429 or 503),
+ * as long as one of the [ "Retry-After" or "retry-after-ms" or "x-ms-retry-after-ms" ] headers has a valid value.
+ *
+ * Returns the `retryAfterInMs` value if the response is a throttling retry response.
+ * If not throttling retry response, returns `undefined`.
+ *
+ * @internal
+ */
+function getRetryAfterInMs(response) {
+    if (!(response && [429, 503].includes(response.status)))
+        return undefined;
+    try {
+        // Headers: "retry-after-ms", "x-ms-retry-after-ms", "Retry-After"
+        for (const header of AllRetryAfterHeaders) {
+            const retryAfterValue = parseHeaderValueAsNumber(response, header);
+            if (retryAfterValue === 0 || retryAfterValue) {
+                // "Retry-After" header ==> seconds
+                // "retry-after-ms", "x-ms-retry-after-ms" headers ==> milli-seconds
+                const multiplyingFactor = header === RetryAfterHeader ? 1000 : 1;
+                return retryAfterValue * multiplyingFactor; // in milli-seconds
+            }
+        }
+        // RetryAfterHeader ("Retry-After") has a special case where it might be formatted as a date instead of a number of seconds
+        const retryAfterHeader = response.headers.get(RetryAfterHeader);
+        if (!retryAfterHeader)
+            return;
+        const date = Date.parse(retryAfterHeader);
+        const diff = date - Date.now();
+        // negative diff would mean a date in the past, so retry asap with 0 milliseconds
+        return Number.isFinite(diff) ? Math.max(0, diff) : undefined;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+/**
+ * A response is a retry response if it has a throttling status code (429 or 503),
+ * as long as one of the [ "Retry-After" or "retry-after-ms" or "x-ms-retry-after-ms" ] headers has a valid value.
+ */
+export function isThrottlingRetryResponse(response) {
+    return Number.isFinite(getRetryAfterInMs(response));
+}
+export function throttlingRetryStrategy() {
+    return {
+        name: "throttlingRetryStrategy",
+        retry({ response }) {
+            const retryAfterInMs = getRetryAfterInMs(response);
+            if (!Number.isFinite(retryAfterInMs)) {
+                return { skipStrategy: true };
+            }
+            return {
+                retryAfterInMs,
+            };
+        },
+    };
+}
+//# sourceMappingURL=throttlingRetryStrategy.js.map

package/dist/esm/retryStrategies/throttlingRetryStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttlingRetryStrategy.js","sourceRoot":"","sources":["../../../src/retryStrategies/throttlingRetryStrategy.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAGlC,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAG9D;;;GAGG;AACH,MAAM,gBAAgB,GAAG,aAAa,CAAC;AACvC;;;;;;GAMG;AACH,MAAM,oBAAoB,GAAa,CAAC,gBAAgB,EAAE,qBAAqB,EAAE,gBAAgB,CAAC,CAAC;AAEnG;;;;;;;;GAQG;AACH,SAAS,iBAAiB,CAAC,QAA2B;IACpD,IAAI,CAAC,CAAC,QAAQ,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1E,IAAI,CAAC;QACH,kEAAkE;QAClE,KAAK,MAAM,MAAM,IAAI,oBAAoB,EAAE,CAAC;YAC1C,MAAM,eAAe,GAAG,wBAAwB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YACnE,IAAI,eAAe,KAAK,CAAC,IAAI,eAAe,EAAE,CAAC;gBAC7C,mCAAmC;gBACnC,oEAAoE;gBACpE,MAAM,iBAAiB,GAAG,MAAM,KAAK,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;gBACjE,OAAO,eAAe,GAAG,iBAAiB,CAAC,CAAC,mBAAmB;YACjE,CAAC;QACH,CAAC;QAED,2HAA2H;QAC3H,MAAM,gBAAgB,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QAChE,IAAI,CAAC,gBAAgB;YAAE,OAAO;QAE9B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAC1C,MAAM,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC/B,iFAAiF;QACjF,OAAO,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC/D,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,yBAAyB,CAAC,QAA2B;IACnE,OAAO,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC;AACtD,CAAC;AAED,MAAM,UAAU,uBAAuB;IACrC,OAAO;QACL,IAAI,EAAE,yBAAyB;QAC/B,KAAK,CAAC,EAAE,QAAQ,EAAE;YAChB,MAAM,cAAc,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;YACnD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;gBACrC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;YAChC,CAAC;YACD,OAAO;gBACL,cAAc;aACf,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\nimport { PipelineResponse } from \"../index.js\";\nimport { parseHeaderValueAsNumber } from \"../util/helpers.js\";\nimport { RetryStrategy } from \"./retryStrategy.js\";\n\n/**\n * The header that comes back from services representing\n * the amount of time (minimum) to wait to retry (in seconds or timestamp after which we can retry).\n */\nconst RetryAfterHeader = \"Retry-After\";\n/**\n * The headers that come back from services representing\n * the amount of time (minimum) to wait to retry.\n *\n * \"retry-after-ms\", \"x-ms-retry-after-ms\" : milliseconds\n * \"Retry-After\" : seconds or timestamp\n */\nconst AllRetryAfterHeaders: string[] = [\"retry-after-ms\", \"x-ms-retry-after-ms\", RetryAfterHeader];\n\n/**\n * A response is a throttling retry response if it has a throttling status code (429 or 503),\n * as long as one of the [ \"Retry-After\" or \"retry-after-ms\" or \"x-ms-retry-after-ms\" ] headers has a valid value.\n *\n * Returns the `retryAfterInMs` value if the response is a throttling retry response.\n * If not throttling retry response, returns `undefined`.\n *\n * @internal\n */\nfunction getRetryAfterInMs(response?: PipelineResponse): number | undefined {\n  if (!(response && [429, 503].includes(response.status))) return undefined;\n  try {\n    // Headers: \"retry-after-ms\", \"x-ms-retry-after-ms\", \"Retry-After\"\n    for (const header of AllRetryAfterHeaders) {\n      const retryAfterValue = parseHeaderValueAsNumber(response, header);\n      if (retryAfterValue === 0 || retryAfterValue) {\n        // \"Retry-After\" header ==> seconds\n        // \"retry-after-ms\", \"x-ms-retry-after-ms\" headers ==> milli-seconds\n        const multiplyingFactor = header === RetryAfterHeader ? 1000 : 1;\n        return retryAfterValue * multiplyingFactor; // in milli-seconds\n      }\n    }\n\n    // RetryAfterHeader (\"Retry-After\") has a special case where it might be formatted as a date instead of a number of seconds\n    const retryAfterHeader = response.headers.get(RetryAfterHeader);\n    if (!retryAfterHeader) return;\n\n    const date = Date.parse(retryAfterHeader);\n    const diff = date - Date.now();\n    // negative diff would mean a date in the past, so retry asap with 0 milliseconds\n    return Number.isFinite(diff) ? Math.max(0, diff) : undefined;\n  } catch (e: any) {\n    return undefined;\n  }\n}\n\n/**\n * A response is a retry response if it has a throttling status code (429 or 503),\n * as long as one of the [ \"Retry-After\" or \"retry-after-ms\" or \"x-ms-retry-after-ms\" ] headers has a valid value.\n */\nexport function isThrottlingRetryResponse(response?: PipelineResponse): boolean {\n  return Number.isFinite(getRetryAfterInMs(response));\n}\n\nexport function throttlingRetryStrategy(): RetryStrategy {\n  return {\n    name: \"throttlingRetryStrategy\",\n    retry({ response }) {\n      const retryAfterInMs = getRetryAfterInMs(response);\n      if (!Number.isFinite(retryAfterInMs)) {\n        return { skipStrategy: true };\n      }\n      return {\n        retryAfterInMs,\n      };\n    },\n  };\n}\n"]}

package/dist/esm/tracing/instrumenter.d.ts

@@ -0,0 +1,16 @@
+import { Instrumenter, TracingSpan } from "./interfaces.js";
+export declare function createDefaultTracingSpan(): TracingSpan;
+export declare function createDefaultInstrumenter(): Instrumenter;
+/**
+ * Extends the SDK with support for a given instrumenter implementation.
+ *
+ * @param instrumenter - The instrumenter implementation to use.
+ */
+export declare function useInstrumenter(instrumenter: Instrumenter): void;
+/**
+ * Gets the currently set instrumenter, a No-Op instrumenter by default.
+ *
+ * @returns The currently set instrumenter
+ */
+export declare function getInstrumenter(): Instrumenter;
+//# sourceMappingURL=instrumenter.d.ts.map

package/dist/esm/tracing/instrumenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumenter.d.ts","sourceRoot":"","sources":["../../../src/tracing/instrumenter.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,YAAY,EAGZ,WAAW,EACZ,MAAM,iBAAiB,CAAC;AAGzB,wBAAgB,wBAAwB,IAAI,WAAW,CAgBtD;AAED,wBAAgB,yBAAyB,IAAI,YAAY,CA4BxD;AAKD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAK9C"}

package/dist/esm/tracing/instrumenter.js

@@ -0,0 +1,61 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { createTracingContext } from "./tracingContext.js";
+export function createDefaultTracingSpan() {
+    return {
+        end: () => {
+            // noop
+        },
+        isRecording: () => false,
+        recordException: () => {
+            // noop
+        },
+        setAttribute: () => {
+            // noop
+        },
+        setStatus: () => {
+            // noop
+        },
+    };
+}
+export function createDefaultInstrumenter() {
+    return {
+        createRequestHeaders: () => {
+            return {};
+        },
+        parseTraceparentHeader: () => {
+            return undefined;
+        },
+        startSpan: (_name, spanOptions) => {
+            return {
+                span: createDefaultTracingSpan(),
+                tracingContext: createTracingContext({ parentContext: spanOptions.tracingContext }),
+            };
+        },
+        withContext(_context, callback, ...callbackArgs) {
+            return callback(...callbackArgs);
+        },
+    };
+}
+/** @internal */
+let instrumenterImplementation;
+/**
+ * Extends the SDK with support for a given instrumenter implementation.
+ *
+ * @param instrumenter - The instrumenter implementation to use.
+ */
+export function useInstrumenter(instrumenter) {
+    instrumenterImplementation = instrumenter;
+}
+/**
+ * Gets the currently set instrumenter, a No-Op instrumenter by default.
+ *
+ * @returns The currently set instrumenter
+ */
+export function getInstrumenter() {
+    if (!instrumenterImplementation) {
+        instrumenterImplementation = createDefaultInstrumenter();
+    }
+    return instrumenterImplementation;
+}
+//# sourceMappingURL=instrumenter.js.map

package/dist/esm/tracing/instrumenter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumenter.js","sourceRoot":"","sources":["../../../src/tracing/instrumenter.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAQlC,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,MAAM,UAAU,wBAAwB;IACtC,OAAO;QACL,GAAG,EAAE,GAAG,EAAE;YACR,OAAO;QACT,CAAC;QACD,WAAW,EAAE,GAAG,EAAE,CAAC,KAAK;QACxB,eAAe,EAAE,GAAG,EAAE;YACpB,OAAO;QACT,CAAC;QACD,YAAY,EAAE,GAAG,EAAE;YACjB,OAAO;QACT,CAAC;QACD,SAAS,EAAE,GAAG,EAAE;YACd,OAAO;QACT,CAAC;KACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,yBAAyB;IACvC,OAAO;QACL,oBAAoB,EAAE,GAA2B,EAAE;YACjD,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,sBAAsB,EAAE,GAA+B,EAAE;YACvD,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,SAAS,EAAE,CACT,KAAa,EACb,WAAoC,EACmB,EAAE;YACzD,OAAO;gBACL,IAAI,EAAE,wBAAwB,EAAE;gBAChC,cAAc,EAAE,oBAAoB,CAAC,EAAE,aAAa,EAAE,WAAW,CAAC,cAAc,EAAE,CAAC;aACpF,CAAC;QACJ,CAAC;QACD,WAAW,CAIT,QAAwB,EACxB,QAAkB,EAClB,GAAG,YAA0B;YAE7B,OAAO,QAAQ,CAAC,GAAG,YAAY,CAAC,CAAC;QACnC,CAAC;KACF,CAAC;AACJ,CAAC;AAED,gBAAgB;AAChB,IAAI,0BAAoD,CAAC;AAEzD;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,YAA0B;IACxD,0BAA0B,GAAG,YAAY,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe;IAC7B,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAChC,0BAA0B,GAAG,yBAAyB,EAAE,CAAC;IAC3D,CAAC;IACD,OAAO,0BAA0B,CAAC;AACpC,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\nimport {\n  Instrumenter,\n  InstrumenterSpanOptions,\n  TracingContext,\n  TracingSpan,\n} from \"./interfaces.js\";\nimport { createTracingContext } from \"./tracingContext.js\";\n\nexport function createDefaultTracingSpan(): TracingSpan {\n  return {\n    end: () => {\n      // noop\n    },\n    isRecording: () => false,\n    recordException: () => {\n      // noop\n    },\n    setAttribute: () => {\n      // noop\n    },\n    setStatus: () => {\n      // noop\n    },\n  };\n}\n\nexport function createDefaultInstrumenter(): Instrumenter {\n  return {\n    createRequestHeaders: (): Record<string, string> => {\n      return {};\n    },\n    parseTraceparentHeader: (): TracingContext | undefined => {\n      return undefined;\n    },\n    startSpan: (\n      _name: string,\n      spanOptions: InstrumenterSpanOptions,\n    ): { span: TracingSpan; tracingContext: TracingContext } => {\n      return {\n        span: createDefaultTracingSpan(),\n        tracingContext: createTracingContext({ parentContext: spanOptions.tracingContext }),\n      };\n    },\n    withContext<\n      CallbackArgs extends unknown[],\n      Callback extends (...args: CallbackArgs) => ReturnType<Callback>,\n    >(\n      _context: TracingContext,\n      callback: Callback,\n      ...callbackArgs: CallbackArgs\n    ): ReturnType<Callback> {\n      return callback(...callbackArgs);\n    },\n  };\n}\n\n/** @internal */\nlet instrumenterImplementation: Instrumenter | undefined;\n\n/**\n * Extends the SDK with support for a given instrumenter implementation.\n *\n * @param instrumenter - The instrumenter implementation to use.\n */\nexport function useInstrumenter(instrumenter: Instrumenter): void {\n  instrumenterImplementation = instrumenter;\n}\n\n/**\n * Gets the currently set instrumenter, a No-Op instrumenter by default.\n *\n * @returns The currently set instrumenter\n */\nexport function getInstrumenter(): Instrumenter {\n  if (!instrumenterImplementation) {\n    instrumenterImplementation = createDefaultInstrumenter();\n  }\n  return instrumenterImplementation;\n}\n"]}

package/dist/esm/tracing/interfaces.d.ts

@@ -0,0 +1,254 @@
+/**
+ * A narrower version of TypeScript 4.5's Awaited type which Recursively
+ * unwraps the "awaited type", emulating the behavior of `await`.
+ */
+export type Resolved<T> = T extends {
+    then(onfulfilled: infer F): any;
+} ? F extends (value: infer V) => any ? Resolved<V> : never : T;
+/**
+ * Represents a client that can integrate with the currently configured {@link Instrumenter}.
+ *
+ * Create an instance using {@link createTracingClient}.
+ */
+export interface TracingClient {
+    /**
+     * Wraps a callback in a tracing span, calls the callback, and closes the span.
+     *
+     * This is the primary interface for using Tracing and will handle error recording as well as setting the status on the span.
+     *
+     * Both synchronous and asynchronous functions will be awaited in order to reflect the result of the callback on the span.
+     *
+     * Example:
+     *
+     * ```ts
+     * const myOperationResult = await tracingClient.withSpan("myClassName.myOperationName", options, (updatedOptions) => myOperation(updatedOptions));
+     * ```
+     * @param name - The name of the span. By convention this should be `${className}.${methodName}`.
+     * @param operationOptions - The original options passed to the method. The callback will receive these options with the newly created {@link TracingContext}.
+     * @param callback - The callback to be invoked with the updated options and newly created {@link TracingSpan}.
+     */
+    withSpan<Options extends {
+        tracingOptions?: OperationTracingOptions;
+    }, Callback extends (updatedOptions: Options, span: Omit<TracingSpan, "end">) => ReturnType<Callback>>(name: string, operationOptions: Options, callback: Callback, spanOptions?: TracingSpanOptions): Promise<Resolved<ReturnType<Callback>>>;
+    /**
+     * Starts a given span but does not set it as the active span.
+     *
+     * You must end the span using {@link TracingSpan.end}.
+     *
+     * Most of the time you will want to use {@link withSpan} instead.
+     *
+     * @param name - The name of the span. By convention this should be `${className}.${methodName}`.
+     * @param operationOptions - The original operation options.
+     * @param spanOptions - The options to use when creating the span.
+     *
+     * @returns A {@link TracingSpan} and the updated operation options.
+     */
+    startSpan<Options extends {
+        tracingOptions?: OperationTracingOptions;
+    }>(name: string, operationOptions?: Options, spanOptions?: TracingSpanOptions): {
+        span: TracingSpan;
+        updatedOptions: OptionsWithTracingContext<Options>;
+    };
+    /**
+     * Wraps a callback with an active context and calls the callback.
+     * Depending on the implementation, this may set the globally available active context.
+     *
+     * Useful when you want to leave the boundaries of the SDK (make a request or callback to user code) and are unable to use the {@link withSpan} API.
+     *
+     * @param context - The {@link TracingContext} to use as the active context in the scope of the callback.
+     * @param callback - The callback to be invoked with the given context set as the globally active context.
+     * @param callbackArgs - The callback arguments.
+     */
+    withContext<CallbackArgs extends unknown[], Callback extends (...args: CallbackArgs) => ReturnType<Callback>>(context: TracingContext, callback: Callback, ...callbackArgs: CallbackArgs): ReturnType<Callback>;
+    /**
+     * Parses a traceparent header value into a {@link TracingSpanContext}.
+     *
+     * @param traceparentHeader - The traceparent header to parse.
+     * @returns An implementation-specific identifier for the span.
+     */
+    parseTraceparentHeader(traceparentHeader: string): TracingContext | undefined;
+    /**
+     * Creates a set of request headers to propagate tracing information to a backend.
+     *
+     * @param tracingContext - The context containing the span to propagate.
+     * @returns The set of headers to add to a request.
+     */
+    createRequestHeaders(tracingContext?: TracingContext): Record<string, string>;
+}
+/**
+ * Options that can be passed to {@link createTracingClient}
+ */
+export interface TracingClientOptions {
+    /** The value of the az.namespace tracing attribute on newly created spans. */
+    namespace: string;
+    /** The name of the package invoking this trace. */
+    packageName: string;
+    /** An optional version of the package invoking this trace. */
+    packageVersion?: string;
+}
+/** The kind of span. */
+export type TracingSpanKind = "client" | "server" | "producer" | "consumer" | "internal";
+/** Options used to configure the newly created span. */
+export interface TracingSpanOptions {
+    /** The kind of span. Implementations should default this to "client". */
+    spanKind?: TracingSpanKind;
+    /** A collection of {@link TracingSpanLink} to link to this span. */
+    spanLinks?: TracingSpanLink[];
+    /** Initial set of attributes to set on a span. */
+    spanAttributes?: {
+        [key: string]: unknown;
+    };
+}
+/** A pointer from the current {@link TracingSpan} to another span in the same or a different trace. */
+export interface TracingSpanLink {
+    /** The {@link TracingContext} containing the span context to link to. */
+    tracingContext: TracingContext;
+    /** A set of attributes on the link. */
+    attributes?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Represents an implementation agnostic instrumenter.
+ */
+export interface Instrumenter {
+    /**
+     * Creates a new {@link TracingSpan} with the given name and options and sets it on a new context.
+     * @param name - The name of the span. By convention this should be `${className}.${methodName}`.
+     * @param spanOptions - The options to use when creating the span.
+     *
+     * @returns A {@link TracingSpan} that can be used to end the span, and the context this span has been set on.
+     */
+    startSpan(name: string, spanOptions: InstrumenterSpanOptions): {
+        span: TracingSpan;
+        tracingContext: TracingContext;
+    };
+    /**
+     * Wraps a callback with an active context and calls the callback.
+     * Depending on the implementation, this may set the globally available active context.
+     *
+     * @param context - The {@link TracingContext} to use as the active context in the scope of the callback.
+     * @param callback - The callback to be invoked with the given context set as the globally active context.
+     * @param callbackArgs - The callback arguments.
+     */
+    withContext<CallbackArgs extends unknown[], Callback extends (...args: CallbackArgs) => ReturnType<Callback>>(context: TracingContext, callback: Callback, ...callbackArgs: CallbackArgs): ReturnType<Callback>;
+    /**
+     * Provides an implementation-specific method to parse a {@link https://www.w3.org/TR/trace-context/#traceparent-header}
+     * into a {@link TracingSpanContext} which can be used to link non-parented spans together.
+     */
+    parseTraceparentHeader(traceparentHeader: string): TracingContext | undefined;
+    /**
+     * Provides an implementation-specific method to serialize a {@link TracingSpan} to a set of headers.
+     * @param tracingContext - The context containing the span to serialize.
+     */
+    createRequestHeaders(tracingContext?: TracingContext): Record<string, string>;
+}
+/**
+ * Options passed to {@link Instrumenter.startSpan} as a superset of {@link TracingSpanOptions}.
+ */
+export interface InstrumenterSpanOptions extends TracingSpanOptions {
+    /** The name of the package invoking this trace. */
+    packageName: string;
+    /** The version of the package invoking this trace. */
+    packageVersion?: string;
+    /** The current tracing context. Defaults to an implementation-specific "active" context. */
+    tracingContext?: TracingContext;
+}
+/**
+ * Status representing a successful operation that can be sent to {@link TracingSpan.setStatus}
+ */
+export type SpanStatusSuccess = {
+    status: "success";
+};
+/**
+ * Status representing an error that can be sent to {@link TracingSpan.setStatus}
+ */
+export type SpanStatusError = {
+    status: "error";
+    error?: Error | string;
+};
+/**
+ * Represents the statuses that can be passed to {@link TracingSpan.setStatus}.
+ *
+ * By default, all spans will be created with status "unset".
+ */
+export type SpanStatus = SpanStatusSuccess | SpanStatusError;
+/**
+ * Represents an implementation agnostic tracing span.
+ */
+export interface TracingSpan {
+    /**
+     * Sets the status of the span. When an error is provided, it will be recorded on the span as well.
+     *
+     * @param status - The {@link SpanStatus} to set on the span.
+     */
+    setStatus(status: SpanStatus): void;
+    /**
+     * Sets a given attribute on a span.
+     *
+     * @param name - The attribute's name.
+     * @param value - The attribute's value to set. May be any non-nullish value.
+     */
+    setAttribute(name: string, value: unknown): void;
+    /**
+     * Ends the span.
+     */
+    end(): void;
+    /**
+     * Records an exception on a {@link TracingSpan} without modifying its status.
+     *
+     * When recording an unhandled exception that should fail the span, please use {@link TracingSpan.setStatus} instead.
+     *
+     * @param exception - The exception to record on the span.
+     *
+     */
+    recordException(exception: Error | string): void;
+    /**
+     * Returns true if this {@link TracingSpan} is recording information.
+     *
+     * Depending on the span implementation, this may return false if the span is not being sampled.
+     */
+    isRecording(): boolean;
+}
+/** An immutable context bag of tracing values for the current operation. */
+export interface TracingContext {
+    /**
+     * Sets a given object on a context.
+     * @param key - The key of the given context value.
+     * @param value - The value to set on the context.
+     *
+     * @returns - A new context with the given value set.
+     */
+    setValue(key: symbol, value: unknown): TracingContext;
+    /**
+     * Gets an object from the context if it exists.
+     * @param key - The key of the given context value.
+     *
+     * @returns - The value of the given context value if it exists, otherwise `undefined`.
+     */
+    getValue(key: symbol): unknown;
+    /**
+     * Deletes an object from the context if it exists.
+     * @param key - The key of the given context value to delete.
+     */
+    deleteValue(key: symbol): TracingContext;
+}
+/**
+ * Tracing options to set on an operation.
+ */
+export interface OperationTracingOptions {
+    /** The context to use for created Tracing Spans. */
+    tracingContext?: TracingContext;
+}
+/**
+ * A utility type for when we know a TracingContext has been set
+ * as part of an operation's options.
+ */
+export type OptionsWithTracingContext<Options extends {
+    tracingOptions?: OperationTracingOptions;
+}> = Options & {
+    tracingOptions: {
+        tracingContext: TracingContext;
+    };
+};
+//# sourceMappingURL=interfaces.d.ts.map

package/dist/esm/tracing/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../src/tracing/interfaces.ts"],"names":[],"mappings":"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"}

package/dist/esm/tracing/interfaces.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+export {};
+//# sourceMappingURL=interfaces.js.map

package/dist/esm/tracing/interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../src/tracing/interfaces.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\n/**\n * A narrower version of TypeScript 4.5's Awaited type which Recursively\n * unwraps the \"awaited type\", emulating the behavior of `await`.\n */\nexport type Resolved<T> = T extends { then(onfulfilled: infer F): any } // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped\n  ? F extends (value: infer V) => any // if the argument to `then` is callable, extracts the first argument\n    ? Resolved<V> // recursively unwrap the value\n    : never // the argument to `then` was not callable\n  : T; // non-object or non-thenable\n\n/**\n * Represents a client that can integrate with the currently configured {@link Instrumenter}.\n *\n * Create an instance using {@link createTracingClient}.\n */\nexport interface TracingClient {\n  /**\n   * Wraps a callback in a tracing span, calls the callback, and closes the span.\n   *\n   * This is the primary interface for using Tracing and will handle error recording as well as setting the status on the span.\n   *\n   * Both synchronous and asynchronous functions will be awaited in order to reflect the result of the callback on the span.\n   *\n   * Example:\n   *\n   * ```ts\n   * const myOperationResult = await tracingClient.withSpan(\"myClassName.myOperationName\", options, (updatedOptions) => myOperation(updatedOptions));\n   * ```\n   * @param name - The name of the span. By convention this should be `${className}.${methodName}`.\n   * @param operationOptions - The original options passed to the method. The callback will receive these options with the newly created {@link TracingContext}.\n   * @param callback - The callback to be invoked with the updated options and newly created {@link TracingSpan}.\n   */\n  withSpan<\n    Options extends { tracingOptions?: OperationTracingOptions },\n    Callback extends (\n      updatedOptions: Options,\n      span: Omit<TracingSpan, \"end\">,\n    ) => ReturnType<Callback>,\n  >(\n    name: string,\n    operationOptions: Options,\n    callback: Callback,\n    spanOptions?: TracingSpanOptions,\n  ): Promise<Resolved<ReturnType<Callback>>>;\n  /**\n   * Starts a given span but does not set it as the active span.\n   *\n   * You must end the span using {@link TracingSpan.end}.\n   *\n   * Most of the time you will want to use {@link withSpan} instead.\n   *\n   * @param name - The name of the span. By convention this should be `${className}.${methodName}`.\n   * @param operationOptions - The original operation options.\n   * @param spanOptions - The options to use when creating the span.\n   *\n   * @returns A {@link TracingSpan} and the updated operation options.\n   */\n  startSpan<Options extends { tracingOptions?: OperationTracingOptions }>(\n    name: string,\n    operationOptions?: Options,\n    spanOptions?: TracingSpanOptions,\n  ): {\n    span: TracingSpan;\n    updatedOptions: OptionsWithTracingContext<Options>;\n  };\n  /**\n   * Wraps a callback with an active context and calls the callback.\n   * Depending on the implementation, this may set the globally available active context.\n   *\n   * Useful when you want to leave the boundaries of the SDK (make a request or callback to user code) and are unable to use the {@link withSpan} API.\n   *\n   * @param context - The {@link TracingContext} to use as the active context in the scope of the callback.\n   * @param callback - The callback to be invoked with the given context set as the globally active context.\n   * @param callbackArgs - The callback arguments.\n   */\n  withContext<\n    CallbackArgs extends unknown[],\n    Callback extends (...args: CallbackArgs) => ReturnType<Callback>,\n  >(\n    context: TracingContext,\n    callback: Callback,\n    ...callbackArgs: CallbackArgs\n  ): ReturnType<Callback>;\n\n  /**\n   * Parses a traceparent header value into a {@link TracingSpanContext}.\n   *\n   * @param traceparentHeader - The traceparent header to parse.\n   * @returns An implementation-specific identifier for the span.\n   */\n  parseTraceparentHeader(traceparentHeader: string): TracingContext | undefined;\n\n  /**\n   * Creates a set of request headers to propagate tracing information to a backend.\n   *\n   * @param tracingContext - The context containing the span to propagate.\n   * @returns The set of headers to add to a request.\n   */\n  createRequestHeaders(tracingContext?: TracingContext): Record<string, string>;\n}\n\n/**\n * Options that can be passed to {@link createTracingClient}\n */\nexport interface TracingClientOptions {\n  /** The value of the az.namespace tracing attribute on newly created spans. */\n  namespace: string;\n  /** The name of the package invoking this trace. */\n  packageName: string;\n  /** An optional version of the package invoking this trace. */\n  packageVersion?: string;\n}\n\n/** The kind of span. */\nexport type TracingSpanKind = \"client\" | \"server\" | \"producer\" | \"consumer\" | \"internal\";\n\n/** Options used to configure the newly created span. */\nexport interface TracingSpanOptions {\n  /** The kind of span. Implementations should default this to \"client\". */\n  spanKind?: TracingSpanKind;\n  /** A collection of {@link TracingSpanLink} to link to this span. */\n  spanLinks?: TracingSpanLink[];\n  /** Initial set of attributes to set on a span. */\n  spanAttributes?: { [key: string]: unknown };\n}\n\n/** A pointer from the current {@link TracingSpan} to another span in the same or a different trace. */\nexport interface TracingSpanLink {\n  /** The {@link TracingContext} containing the span context to link to. */\n  tracingContext: TracingContext;\n  /** A set of attributes on the link. */\n  attributes?: { [key: string]: unknown };\n}\n\n/**\n * Represents an implementation agnostic instrumenter.\n */\nexport interface Instrumenter {\n  /**\n   * Creates a new {@link TracingSpan} with the given name and options and sets it on a new context.\n   * @param name - The name of the span. By convention this should be `${className}.${methodName}`.\n   * @param spanOptions - The options to use when creating the span.\n   *\n   * @returns A {@link TracingSpan} that can be used to end the span, and the context this span has been set on.\n   */\n  startSpan(\n    name: string,\n    spanOptions: InstrumenterSpanOptions,\n  ): { span: TracingSpan; tracingContext: TracingContext };\n  /**\n   * Wraps a callback with an active context and calls the callback.\n   * Depending on the implementation, this may set the globally available active context.\n   *\n   * @param context - The {@link TracingContext} to use as the active context in the scope of the callback.\n   * @param callback - The callback to be invoked with the given context set as the globally active context.\n   * @param callbackArgs - The callback arguments.\n   */\n  withContext<\n    CallbackArgs extends unknown[],\n    Callback extends (...args: CallbackArgs) => ReturnType<Callback>,\n  >(\n    context: TracingContext,\n    callback: Callback,\n    ...callbackArgs: CallbackArgs\n  ): ReturnType<Callback>;\n\n  /**\n   * Provides an implementation-specific method to parse a {@link https://www.w3.org/TR/trace-context/#traceparent-header}\n   * into a {@link TracingSpanContext} which can be used to link non-parented spans together.\n   */\n  parseTraceparentHeader(traceparentHeader: string): TracingContext | undefined;\n  /**\n   * Provides an implementation-specific method to serialize a {@link TracingSpan} to a set of headers.\n   * @param tracingContext - The context containing the span to serialize.\n   */\n  createRequestHeaders(tracingContext?: TracingContext): Record<string, string>;\n}\n\n/**\n * Options passed to {@link Instrumenter.startSpan} as a superset of {@link TracingSpanOptions}.\n */\nexport interface InstrumenterSpanOptions extends TracingSpanOptions {\n  /** The name of the package invoking this trace. */\n  packageName: string;\n  /** The version of the package invoking this trace. */\n  packageVersion?: string;\n  /** The current tracing context. Defaults to an implementation-specific \"active\" context. */\n  tracingContext?: TracingContext;\n}\n\n/**\n * Status representing a successful operation that can be sent to {@link TracingSpan.setStatus}\n */\nexport type SpanStatusSuccess = { status: \"success\" };\n\n/**\n * Status representing an error that can be sent to {@link TracingSpan.setStatus}\n */\nexport type SpanStatusError = { status: \"error\"; error?: Error | string };\n\n/**\n * Represents the statuses that can be passed to {@link TracingSpan.setStatus}.\n *\n * By default, all spans will be created with status \"unset\".\n */\nexport type SpanStatus = SpanStatusSuccess | SpanStatusError;\n\n/**\n * Represents an implementation agnostic tracing span.\n */\nexport interface TracingSpan {\n  /**\n   * Sets the status of the span. When an error is provided, it will be recorded on the span as well.\n   *\n   * @param status - The {@link SpanStatus} to set on the span.\n   */\n  setStatus(status: SpanStatus): void;\n\n  /**\n   * Sets a given attribute on a span.\n   *\n   * @param name - The attribute's name.\n   * @param value - The attribute's value to set. May be any non-nullish value.\n   */\n  setAttribute(name: string, value: unknown): void;\n\n  /**\n   * Ends the span.\n   */\n  end(): void;\n\n  /**\n   * Records an exception on a {@link TracingSpan} without modifying its status.\n   *\n   * When recording an unhandled exception that should fail the span, please use {@link TracingSpan.setStatus} instead.\n   *\n   * @param exception - The exception to record on the span.\n   *\n   */\n  recordException(exception: Error | string): void;\n\n  /**\n   * Returns true if this {@link TracingSpan} is recording information.\n   *\n   * Depending on the span implementation, this may return false if the span is not being sampled.\n   */\n  isRecording(): boolean;\n}\n\n/** An immutable context bag of tracing values for the current operation. */\nexport interface TracingContext {\n  /**\n   * Sets a given object on a context.\n   * @param key - The key of the given context value.\n   * @param value - The value to set on the context.\n   *\n   * @returns - A new context with the given value set.\n   */\n  setValue(key: symbol, value: unknown): TracingContext;\n  /**\n   * Gets an object from the context if it exists.\n   * @param key - The key of the given context value.\n   *\n   * @returns - The value of the given context value if it exists, otherwise `undefined`.\n   */\n  getValue(key: symbol): unknown;\n  /**\n   * Deletes an object from the context if it exists.\n   * @param key - The key of the given context value to delete.\n   */\n  deleteValue(key: symbol): TracingContext;\n}\n\n/**\n * Tracing options to set on an operation.\n */\nexport interface OperationTracingOptions {\n  /** The context to use for created Tracing Spans. */\n  tracingContext?: TracingContext;\n}\n\n/**\n * A utility type for when we know a TracingContext has been set\n * as part of an operation's options.\n */\nexport type OptionsWithTracingContext<\n  Options extends { tracingOptions?: OperationTracingOptions },\n> = Options & {\n  tracingOptions: {\n    tracingContext: TracingContext;\n  };\n};\n"]}

package/dist/esm/tracing/tracingClient.d.ts

@@ -0,0 +1,9 @@
+import { TracingClient, TracingClientOptions } from "./interfaces.js";
+/**
+ * Creates a new tracing client.
+ *
+ * @param options - Options used to configure the tracing client.
+ * @returns - An instance of {@link TracingClient}.
+ */
+export declare function createTracingClient(options: TracingClientOptions): TracingClient;
+//# sourceMappingURL=tracingClient.d.ts.map

package/dist/esm/tracing/tracingClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracingClient.d.ts","sourceRoot":"","sources":["../../../src/tracing/tracingClient.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,aAAa,EACb,oBAAoB,EAIrB,MAAM,iBAAiB,CAAC;AAIzB;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa,CAkGhF"}