@opentelemetry/instrumentation-fetch 0.57.2 → 0.200.0-dev.1

package/README.md

@@ -66,11 +66,12 @@ See [examples/tracer-web/fetch](https://github.com/open-telemetry/opentelemetry-
 
 Fetch instrumentation plugin has few options available to choose from. You can set the following:
 
-| Options                                                                                                                                                                  | Type                          | Description                                                                             |
-|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------|-----------------------------------------------------------------------------------------|
-| [`applyCustomAttributesOnSpan`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-fetch/src/fetch.ts#L75) | `HttpCustomAttributeFunction` | Function for adding custom attributes                                                   |
-| [`ignoreNetworkEvents`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-fetch/src/fetch.ts#L77)         | `boolean`                     | Disable network events being added as span events (network events are added by default) |
-| [`measureRequestSize`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-fetch/src/fetch.ts#L79)          | `boolean`                     | Measure outgoing request length (outgoing request length is not measured by default)    |
+| Options | Type | Description |
+| ------- | ---- | ----------- |
+| [`applyCustomAttributesOnSpan`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-fetch/src/fetch.ts#L83) | `FetchCustomAttributeFunction` | Function for adding custom attributes |
+| [`requestHook`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-fetch/src/fetch.ts#L85) | `FetchRequestHookFunction` | Function for adding custom attributes or headers before the request is handled |
+| [`ignoreNetworkEvents`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-fetch/src/fetch.ts#L87) | `boolean`| Disable network events being added as span events (network events are added by default) |
+| [`measureRequestSize`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-fetch/src/fetch.ts#L89) | `boolean` | Measure outgoing request length (outgoing request length is not measured by default)    |
 
 ## Semantic Conventions
 

package/build/esm/fetch.d.ts

@@ -5,6 +5,9 @@ import { FetchError } from './types';
 export interface FetchCustomAttributeFunction {
     (span: api.Span, request: Request | RequestInit, result: Response | FetchError): void;
 }
+export interface FetchRequestHookFunction {
+    (span: api.Span, request: Request | RequestInit): void;
+}
 /**
  * FetchPlugin Config
  */
@@ -19,6 +22,8 @@ export interface FetchInstrumentationConfig extends InstrumentationConfig {
     ignoreUrls?: Array<string | RegExp>;
     /** Function for adding custom attributes on the span */
     applyCustomAttributesOnSpan?: FetchCustomAttributeFunction;
+    /** Function for adding custom attributes or headers before the request is handled */
+    requestHook?: FetchRequestHookFunction;
     ignoreNetworkEvents?: boolean;
     /** Measure outgoing request size */
     measureRequestSize?: boolean;
@@ -91,6 +96,7 @@ export declare class FetchInstrumentation extends InstrumentationBase<FetchInstr
      */
     private _patchConstructor;
     private _applyAttributesAfterFetch;
+    private _callRequestHook;
     /**
      * Prepares a span data - needed later for matching appropriate network
      *     resources

package/build/esm/fetch.js

@@ -13,47 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var _a;
 import * as api from '@opentelemetry/api';
 import { isWrapped, InstrumentationBase, safeExecuteInTheMiddle, } from '@opentelemetry/instrumentation';
 import * as core from '@opentelemetry/core';
@@ -67,43 +26,40 @@ import { _globalThis } from '@opentelemetry/core';
 // this is needed as event "load" is called before observer
 // hard to say how long it should really wait, seems like 300ms is
 // safe enough
-var OBSERVER_WAIT_TIME_MS = 300;
-var isNode = typeof process === 'object' && ((_a = process.release) === null || _a === void 0 ? void 0 : _a.name) === 'node';
+const OBSERVER_WAIT_TIME_MS = 300;
+const isNode = typeof process === 'object' && process.release?.name === 'node';
 /**
  * This class represents a fetch plugin for auto instrumentation
  */
-var FetchInstrumentation = /** @class */ (function (_super) {
-    __extends(FetchInstrumentation, _super);
-    function FetchInstrumentation(config) {
-        if (config === void 0) { config = {}; }
-        var _this = _super.call(this, '@opentelemetry/instrumentation-fetch', VERSION, config) || this;
-        _this.component = 'fetch';
-        _this.version = VERSION;
-        _this.moduleName = _this.component;
-        _this._usedResources = new WeakSet();
-        _this._tasksCount = 0;
-        return _this;
+export class FetchInstrumentation extends InstrumentationBase {
+    component = 'fetch';
+    version = VERSION;
+    moduleName = this.component;
+    _usedResources = new WeakSet();
+    _tasksCount = 0;
+    constructor(config = {}) {
+        super('@opentelemetry/instrumentation-fetch', VERSION, config);
     }
-    FetchInstrumentation.prototype.init = function () { };
+    init() { }
     /**
      * Add cors pre flight child span
      * @param span
      * @param corsPreFlightRequest
      */
-    FetchInstrumentation.prototype._addChildSpan = function (span, corsPreFlightRequest) {
-        var childSpan = this.tracer.startSpan('CORS Preflight', {
+    _addChildSpan(span, corsPreFlightRequest) {
+        const childSpan = this.tracer.startSpan('CORS Preflight', {
             startTime: corsPreFlightRequest[web.PerformanceTimingNames.FETCH_START],
         }, api.trace.setSpan(api.context.active(), span));
         web.addSpanNetworkEvents(childSpan, corsPreFlightRequest, this.getConfig().ignoreNetworkEvents);
         childSpan.end(corsPreFlightRequest[web.PerformanceTimingNames.RESPONSE_END]);
-    };
+    }
     /**
      * Adds more attributes to span just before ending it
      * @param span
      * @param response
      */
-    FetchInstrumentation.prototype._addFinalSpanAttributes = function (span, response) {
-        var parsedUrl = web.parseUrl(response.url);
+    _addFinalSpanAttributes(span, response) {
+        const parsedUrl = web.parseUrl(response.url);
         span.setAttribute(SEMATTRS_HTTP_STATUS_CODE, response.status);
         if (response.statusText != null) {
             span.setAttribute(AttributeNames.HTTP_STATUS_TEXT, response.statusText);
@@ -113,15 +69,15 @@ var FetchInstrumentation = /** @class */ (function (_super) {
         if (typeof navigator !== 'undefined') {
             span.setAttribute(SEMATTRS_HTTP_USER_AGENT, navigator.userAgent);
         }
-    };
+    }
     /**
      * Add headers
      * @param options
      * @param spanUrl
      */
-    FetchInstrumentation.prototype._addHeaders = function (options, spanUrl) {
+    _addHeaders(options, spanUrl) {
         if (!web.shouldPropagateTraceHeaders(spanUrl, this.getConfig().propagateTraceHeaderCorsUrls)) {
-            var headers = {};
+            const headers = {};
             api.propagation.inject(api.context.active(), headers);
             if (Object.keys(headers).length > 0) {
                 this._diag.debug('headers inject skipped due to CORS policy');
@@ -130,68 +86,66 @@ var FetchInstrumentation = /** @class */ (function (_super) {
         }
         if (options instanceof Request) {
             api.propagation.inject(api.context.active(), options.headers, {
-                set: function (h, k, v) { return h.set(k, typeof v === 'string' ? v : String(v)); },
+                set: (h, k, v) => h.set(k, typeof v === 'string' ? v : String(v)),
             });
         }
         else if (options.headers instanceof Headers) {
             api.propagation.inject(api.context.active(), options.headers, {
-                set: function (h, k, v) { return h.set(k, typeof v === 'string' ? v : String(v)); },
+                set: (h, k, v) => h.set(k, typeof v === 'string' ? v : String(v)),
             });
         }
         else if (options.headers instanceof Map) {
             api.propagation.inject(api.context.active(), options.headers, {
-                set: function (h, k, v) { return h.set(k, typeof v === 'string' ? v : String(v)); },
+                set: (h, k, v) => h.set(k, typeof v === 'string' ? v : String(v)),
             });
         }
         else {
-            var headers = {};
+            const headers = {};
             api.propagation.inject(api.context.active(), headers);
             options.headers = Object.assign({}, headers, options.headers || {});
         }
-    };
+    }
     /**
      * Clears the resource timings and all resources assigned with spans
      *     when {@link FetchPluginConfig.clearTimingResources} is
      *     set to true (default false)
      * @private
      */
-    FetchInstrumentation.prototype._clearResources = function () {
+    _clearResources() {
         if (this._tasksCount === 0 && this.getConfig().clearTimingResources) {
             performance.clearResourceTimings();
             this._usedResources = new WeakSet();
         }
-    };
+    }
     /**
      * Creates a new span
      * @param url
      * @param options
      */
-    FetchInstrumentation.prototype._createSpan = function (url, options) {
-        var _a;
-        if (options === void 0) { options = {}; }
+    _createSpan(url, options = {}) {
         if (core.isUrlIgnored(url, this.getConfig().ignoreUrls)) {
             this._diag.debug('ignoring span as url matches ignored url');
             return;
         }
-        var method = (options.method || 'GET').toUpperCase();
-        var spanName = "HTTP " + method;
+        const method = (options.method || 'GET').toUpperCase();
+        const spanName = `HTTP ${method}`;
         return this.tracer.startSpan(spanName, {
             kind: api.SpanKind.CLIENT,
-            attributes: (_a = {},
-                _a[AttributeNames.COMPONENT] = this.moduleName,
-                _a[SEMATTRS_HTTP_METHOD] = method,
-                _a[SEMATTRS_HTTP_URL] = url,
-                _a),
+            attributes: {
+                [AttributeNames.COMPONENT]: this.moduleName,
+                [SEMATTRS_HTTP_METHOD]: method,
+                [SEMATTRS_HTTP_URL]: url,
+            },
         });
-    };
+    }
     /**
      * Finds appropriate resource and add network events to the span
      * @param span
      * @param resourcesObserver
      * @param endTime
      */
-    FetchInstrumentation.prototype._findResourceAndAddNetworkEvents = function (span, resourcesObserver, endTime) {
-        var resources = resourcesObserver.entries;
+    _findResourceAndAddNetworkEvents(span, resourcesObserver, endTime) {
+        let resources = resourcesObserver.entries;
         if (!resources.length) {
             if (!performance.getEntriesByType) {
                 return;
@@ -201,74 +155,68 @@ var FetchInstrumentation = /** @class */ (function (_super) {
             // information
             resources = performance.getEntriesByType('resource');
         }
-        var resource = web.getResource(resourcesObserver.spanUrl, resourcesObserver.startTime, endTime, resources, this._usedResources, 'fetch');
+        const resource = web.getResource(resourcesObserver.spanUrl, resourcesObserver.startTime, endTime, resources, this._usedResources, 'fetch');
         if (resource.mainRequest) {
-            var mainRequest = resource.mainRequest;
+            const mainRequest = resource.mainRequest;
             this._markResourceAsUsed(mainRequest);
-            var corsPreFlightRequest = resource.corsPreFlightRequest;
+            const corsPreFlightRequest = resource.corsPreFlightRequest;
             if (corsPreFlightRequest) {
                 this._addChildSpan(span, corsPreFlightRequest);
                 this._markResourceAsUsed(corsPreFlightRequest);
             }
             web.addSpanNetworkEvents(span, mainRequest, this.getConfig().ignoreNetworkEvents);
         }
-    };
+    }
     /**
      * Marks certain [resource]{@link PerformanceResourceTiming} when information
      * from this is used to add events to span.
      * This is done to avoid reusing the same resource again for next span
      * @param resource
      */
-    FetchInstrumentation.prototype._markResourceAsUsed = function (resource) {
+    _markResourceAsUsed(resource) {
         this._usedResources.add(resource);
-    };
+    }
     /**
      * Finish span, add attributes, network events etc.
      * @param span
      * @param spanData
      * @param response
      */
-    FetchInstrumentation.prototype._endSpan = function (span, spanData, response) {
-        var _this = this;
-        var endTime = core.millisToHrTime(Date.now());
-        var performanceEndTime = core.hrTime();
+    _endSpan(span, spanData, response) {
+        const endTime = core.millisToHrTime(Date.now());
+        const performanceEndTime = core.hrTime();
         this._addFinalSpanAttributes(span, response);
-        setTimeout(function () {
-            var _a;
-            (_a = spanData.observer) === null || _a === void 0 ? void 0 : _a.disconnect();
-            _this._findResourceAndAddNetworkEvents(span, spanData, performanceEndTime);
-            _this._tasksCount--;
-            _this._clearResources();
+        setTimeout(() => {
+            spanData.observer?.disconnect();
+            this._findResourceAndAddNetworkEvents(span, spanData, performanceEndTime);
+            this._tasksCount--;
+            this._clearResources();
             span.end(endTime);
         }, OBSERVER_WAIT_TIME_MS);
-    };
+    }
     /**
      * Patches the constructor of fetch
      */
-    FetchInstrumentation.prototype._patchConstructor = function () {
-        var _this = this;
-        return function (original) {
-            var plugin = _this;
-            return function patchConstructor() {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var self = this;
-                var url = web.parseUrl(args[0] instanceof Request ? args[0].url : String(args[0])).href;
-                var options = args[0] instanceof Request ? args[0] : args[1] || {};
-                var createdSpan = plugin._createSpan(url, options);
+    _patchConstructor() {
+        return original => {
+            const plugin = this;
+            return function patchConstructor(...args) {
+                const self = this;
+                const url = web.parseUrl(args[0] instanceof Request ? args[0].url : String(args[0])).href;
+                const options = args[0] instanceof Request ? args[0] : args[1] || {};
+                const createdSpan = plugin._createSpan(url, options);
                 if (!createdSpan) {
                     return original.apply(this, args);
                 }
-                var spanData = plugin._prepareSpanData(url);
+                const spanData = plugin._prepareSpanData(url);
                 if (plugin.getConfig().measureRequestSize) {
-                    getFetchBodyLength.apply(void 0, __spreadArray([], __read(args), false)).then(function (length) {
+                    getFetchBodyLength(...args)
+                        .then(length => {
                         if (!length)
                             return;
                         createdSpan.setAttribute(SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED, length);
                     })
-                        .catch(function (error) {
+                        .catch(error => {
                         plugin._diag.warn('getFetchBodyLength', error);
                     });
                 }
@@ -277,7 +225,7 @@ var FetchInstrumentation = /** @class */ (function (_super) {
                     plugin._endSpan(span, spanData, {
                         status: error.status || 0,
                         statusText: error.message,
-                        url: url,
+                        url,
                     });
                 }
                 function endSpanOnSuccess(span, response) {
@@ -289,31 +237,29 @@ var FetchInstrumentation = /** @class */ (function (_super) {
                         plugin._endSpan(span, spanData, {
                             status: response.status,
                             statusText: response.statusText,
-                            url: url,
+                            url,
                         });
                     }
                 }
                 function onSuccess(span, resolve, response) {
                     try {
-                        var resClone = response.clone();
-                        var resClone4Hook_1 = response.clone();
-                        var body = resClone.body;
+                        const resClone = response.clone();
+                        const body = resClone.body;
                         if (body) {
-                            var reader_1 = body.getReader();
-                            var read_1 = function () {
-                                reader_1.read().then(function (_a) {
-                                    var done = _a.done;
+                            const reader = body.getReader();
+                            const read = () => {
+                                reader.read().then(({ done }) => {
                                     if (done) {
-                                        endSpanOnSuccess(span, resClone4Hook_1);
+                                        endSpanOnSuccess(span, response);
                                     }
                                     else {
-                                        read_1();
+                                        read();
                                     }
-                                }, function (error) {
+                                }, error => {
                                     endSpanOnError(span, error);
                                 });
                             };
-                            read_1();
+                            read();
                         }
                         else {
                             // some older browsers don't have .body implemented
@@ -332,9 +278,11 @@ var FetchInstrumentation = /** @class */ (function (_super) {
                         reject(error);
                     }
                 }
-                return new Promise(function (resolve, reject) {
-                    return api.context.with(api.trace.setSpan(api.context.active(), createdSpan), function () {
+                return new Promise((resolve, reject) => {
+                    return api.context.with(api.trace.setSpan(api.context.active(), createdSpan), () => {
                         plugin._addHeaders(options, url);
+                        // Important to execute "_callRequestHook" after "_addHeaders", allowing the consumer code to override the request headers.
+                        plugin._callRequestHook(createdSpan, options);
                         plugin._tasksCount++;
                         // TypeScript complains about arrow function captured a this typed as globalThis
                         // ts(7041)
@@ -345,33 +293,43 @@ var FetchInstrumentation = /** @class */ (function (_super) {
                 });
             };
         };
-    };
-    FetchInstrumentation.prototype._applyAttributesAfterFetch = function (span, request, result) {
-        var _this = this;
-        var applyCustomAttributesOnSpan = this.getConfig().applyCustomAttributesOnSpan;
+    }
+    _applyAttributesAfterFetch(span, request, result) {
+        const applyCustomAttributesOnSpan = this.getConfig().applyCustomAttributesOnSpan;
         if (applyCustomAttributesOnSpan) {
-            safeExecuteInTheMiddle(function () { return applyCustomAttributesOnSpan(span, request, result); }, function (error) {
+            safeExecuteInTheMiddle(() => applyCustomAttributesOnSpan(span, request, result), error => {
+                if (!error) {
+                    return;
+                }
+                this._diag.error('applyCustomAttributesOnSpan', error);
+            }, true);
+        }
+    }
+    _callRequestHook(span, request) {
+        const requestHook = this.getConfig().requestHook;
+        if (requestHook) {
+            safeExecuteInTheMiddle(() => requestHook(span, request), error => {
                 if (!error) {
                     return;
                 }
-                _this._diag.error('applyCustomAttributesOnSpan', error);
+                this._diag.error('requestHook', error);
             }, true);
         }
-    };
+    }
     /**
      * Prepares a span data - needed later for matching appropriate network
      *     resources
      * @param spanUrl
      */
-    FetchInstrumentation.prototype._prepareSpanData = function (spanUrl) {
-        var startTime = core.hrTime();
-        var entries = [];
+    _prepareSpanData(spanUrl) {
+        const startTime = core.hrTime();
+        const entries = [];
         if (typeof PerformanceObserver !== 'function') {
-            return { entries: entries, startTime: startTime, spanUrl: spanUrl };
+            return { entries, startTime, spanUrl };
         }
-        var observer = new PerformanceObserver(function (list) {
-            var perfObsEntries = list.getEntries();
-            perfObsEntries.forEach(function (entry) {
+        const observer = new PerformanceObserver(list => {
+            const perfObsEntries = list.getEntries();
+            perfObsEntries.forEach(entry => {
                 if (entry.initiatorType === 'fetch' && entry.name === spanUrl) {
                     entries.push(entry);
                 }
@@ -380,12 +338,12 @@ var FetchInstrumentation = /** @class */ (function (_super) {
         observer.observe({
             entryTypes: ['resource'],
         });
-        return { entries: entries, observer: observer, startTime: startTime, spanUrl: spanUrl };
-    };
+        return { entries, observer, startTime, spanUrl };
+    }
     /**
      * implements enable function
      */
-    FetchInstrumentation.prototype.enable = function () {
+    enable() {
         if (isNode) {
             // Node.js v18+ *does* have a global `fetch()`, but this package does not
             // support instrumenting it.
@@ -397,18 +355,16 @@ var FetchInstrumentation = /** @class */ (function (_super) {
             this._diag.debug('removing previous patch for constructor');
         }
         this._wrap(_globalThis, 'fetch', this._patchConstructor());
-    };
+    }
     /**
      * implements unpatch function
      */
-    FetchInstrumentation.prototype.disable = function () {
+    disable() {
         if (isNode) {
             return;
         }
         this._unwrap(_globalThis, 'fetch');
         this._usedResources = new WeakSet();
-    };
-    return FetchInstrumentation;
-}(InstrumentationBase));
-export { FetchInstrumentation };
+    }
+}
 //# sourceMappingURL=fetch.js.map