????
Your IP : 3.138.197.104
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
/** @internal */
const knownContextKeys = {
span: Symbol.for("@azure/core-tracing span"),
namespace: Symbol.for("@azure/core-tracing namespace"),
};
/**
* Creates a new {@link TracingContext} with the given options.
* @param options - A set of known keys that may be set on the context.
* @returns A new {@link TracingContext} with the given options.
*
* @internal
*/
function createTracingContext(options = {}) {
let context = new TracingContextImpl(options.parentContext);
if (options.span) {
context = context.setValue(knownContextKeys.span, options.span);
}
if (options.namespace) {
context = context.setValue(knownContextKeys.namespace, options.namespace);
}
return context;
}
/** @internal */
class TracingContextImpl {
constructor(initialContext) {
this._contextMap =
initialContext instanceof TracingContextImpl
? new Map(initialContext._contextMap)
: new Map();
}
setValue(key, value) {
const newContext = new TracingContextImpl(this);
newContext._contextMap.set(key, value);
return newContext;
}
getValue(key) {
return this._contextMap.get(key);
}
deleteValue(key) {
const newContext = new TracingContextImpl(this);
newContext._contextMap.delete(key);
return newContext;
}
}
// Copyright (c) Microsoft Corporation.
function createDefaultTracingSpan() {
return {
end: () => {
// noop
},
isRecording: () => false,
recordException: () => {
// noop
},
setAttribute: () => {
// noop
},
setStatus: () => {
// noop
},
};
}
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 Azure SDK with support for a given instrumenter implementation.
*
* @param instrumenter - The instrumenter implementation to use.
*/
function useInstrumenter(instrumenter) {
instrumenterImplementation = instrumenter;
}
/**
* Gets the currently set instrumenter, a No-Op instrumenter by default.
*
* @returns The currently set instrumenter
*/
function getInstrumenter() {
if (!instrumenterImplementation) {
instrumenterImplementation = createDefaultInstrumenter();
}
return instrumenterImplementation;
}
// Copyright (c) Microsoft Corporation.
/**
* Creates a new tracing client.
*
* @param options - Options used to configure the tracing client.
* @returns - An instance of {@link TracingClient}.
*/
function createTracingClient(options) {
const { namespace, packageName, packageVersion } = options;
function startSpan(name, operationOptions, spanOptions) {
var _a;
const startSpanResult = getInstrumenter().startSpan(name, Object.assign(Object.assign({}, spanOptions), { packageName: packageName, packageVersion: packageVersion, tracingContext: (_a = operationOptions === null || operationOptions === void 0 ? void 0 : operationOptions.tracingOptions) === null || _a === void 0 ? void 0 : _a.tracingContext }));
let tracingContext = startSpanResult.tracingContext;
const span = startSpanResult.span;
if (!tracingContext.getValue(knownContextKeys.namespace)) {
tracingContext = tracingContext.setValue(knownContextKeys.namespace, namespace);
}
span.setAttribute("az.namespace", tracingContext.getValue(knownContextKeys.namespace));
const updatedOptions = Object.assign({}, operationOptions, {
tracingOptions: Object.assign(Object.assign({}, operationOptions === null || operationOptions === void 0 ? void 0 : operationOptions.tracingOptions), { tracingContext }),
});
return {
span,
updatedOptions,
};
}
async function withSpan(name, operationOptions, callback, spanOptions) {
const { span, updatedOptions } = startSpan(name, operationOptions, spanOptions);
try {
const result = await withContext(updatedOptions.tracingOptions.tracingContext, () => Promise.resolve(callback(updatedOptions, span)));
span.setStatus({ status: "success" });
return result;
}
catch (err) {
span.setStatus({ status: "error", error: err });
throw err;
}
finally {
span.end();
}
}
function withContext(context, callback, ...callbackArgs) {
return getInstrumenter().withContext(context, callback, ...callbackArgs);
}
/**
* Parses a traceparent header value into a span identifier.
*
* @param traceparentHeader - The traceparent header to parse.
* @returns An implementation-specific identifier for the span.
*/
function parseTraceparentHeader(traceparentHeader) {
return getInstrumenter().parseTraceparentHeader(traceparentHeader);
}
/**
* Creates a set of request headers to propagate tracing information to a backend.
*
* @param tracingContext - The context containing the span to serialize.
* @returns The set of headers to add to a request.
*/
function createRequestHeaders(tracingContext) {
return getInstrumenter().createRequestHeaders(tracingContext);
}
return {
startSpan,
withSpan,
withContext,
parseTraceparentHeader,
createRequestHeaders,
};
}
exports.createTracingClient = createTracingClient;
exports.useInstrumenter = useInstrumenter;
//# sourceMappingURL=index.js.map