@sentry/node 10.53.0 → 10.54.0

package/build/esm/integrations/tracing/connect/index.js

@@ -0,0 +1,52 @@
+import { ConnectInstrumentation } from './vendored/instrumentation.js';
+import { defineIntegration, getClient, captureException, spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { generateInstrumentOnce, ensureIsWrapped } from '@sentry/node-core';
+
+const INTEGRATION_NAME = "Connect";
+const instrumentConnect = generateInstrumentOnce(INTEGRATION_NAME, () => new ConnectInstrumentation());
+const _connectIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentConnect();
+    }
+  };
+});
+const connectIntegration = defineIntegration(_connectIntegration);
+function connectErrorMiddleware(err, req, res, next) {
+  captureException(err, {
+    mechanism: {
+      handled: false,
+      type: "auto.middleware.connect"
+    }
+  });
+  next(err);
+}
+const setupConnectErrorHandler = (app) => {
+  app.use(connectErrorMiddleware);
+  const client = getClient();
+  if (client) {
+    client.on("spanStart", (span) => {
+      addConnectSpanAttributes(span);
+    });
+  }
+  ensureIsWrapped(app.use, "connect");
+};
+function addConnectSpanAttributes(span) {
+  const attributes = spanToJSON(span).data;
+  const type = attributes["connect.type"];
+  if (attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] || !type) {
+    return;
+  }
+  span.setAttributes({
+    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.http.otel.connect",
+    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `${type}.connect`
+  });
+  const name = attributes["connect.name"];
+  if (typeof name === "string") {
+    span.updateName(name);
+  }
+}
+
+export { connectIntegration, instrumentConnect, setupConnectErrorHandler };
+//# sourceMappingURL=index.js.map

package/build/esm/integrations/tracing/connect/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/connect/index.ts"],"sourcesContent":["import { ConnectInstrumentation } from './vendored/instrumentation';\nimport type { IntegrationFn, Span } from '@sentry/core';\nimport {\n  captureException,\n  defineIntegration,\n  getClient,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  spanToJSON,\n} from '@sentry/core';\nimport { ensureIsWrapped, generateInstrumentOnce } from '@sentry/node-core';\n\ntype ConnectApp = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  use: (middleware: any) => void;\n};\n\nconst INTEGRATION_NAME = 'Connect';\n\nexport const instrumentConnect = generateInstrumentOnce(INTEGRATION_NAME, () => new ConnectInstrumentation());\n\nconst _connectIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentConnect();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for [Connect](https://github.com/senchalabs/connect/).\n *\n * If you also want to capture errors, you need to call `setupConnectErrorHandler(app)` after you initialize your connect app.\n *\n * For more information, see the [connect documentation](https://docs.sentry.io/platforms/javascript/guides/connect/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [Sentry.connectIntegration()],\n * })\n * ```\n */\nexport const connectIntegration = defineIntegration(_connectIntegration);\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction connectErrorMiddleware(err: any, req: any, res: any, next: any): void {\n  captureException(err, {\n    mechanism: {\n      handled: false,\n      type: 'auto.middleware.connect',\n    },\n  });\n  next(err);\n}\n\n/**\n * Add a Connect middleware to capture errors to Sentry.\n *\n * @param app The Connect app to attach the error handler to\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n * const connect = require(\"connect\");\n *\n * const app = connect();\n *\n * Sentry.setupConnectErrorHandler(app);\n *\n * // Add you connect routes here\n *\n * app.listen(3000);\n * ```\n */\nexport const setupConnectErrorHandler = (app: ConnectApp): void => {\n  app.use(connectErrorMiddleware);\n\n  // Sadly, ConnectInstrumentation has no requestHook, so we need to add the attributes here\n  // We register this hook in this method, because if we register it in the integration `setup`,\n  // it would always run even for users that are not even using connect\n  const client = getClient();\n  if (client) {\n    client.on('spanStart', span => {\n      addConnectSpanAttributes(span);\n    });\n  }\n\n  ensureIsWrapped(app.use, 'connect');\n};\n\nfunction addConnectSpanAttributes(span: Span): void {\n  const attributes = spanToJSON(span).data;\n\n  // this is one of: middleware, request_handler\n  const type = attributes['connect.type'];\n\n  // If this is already set, or we have no connect span, no need to process again...\n  if (attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] || !type) {\n    return;\n  }\n\n  span.setAttributes({\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.otel.connect',\n    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `${type}.connect`,\n  });\n\n  // Also update the name, we don't need the \"middleware - \" prefix\n  const name = attributes['connect.name'];\n  if (typeof name === 'string') {\n    span.updateName(name);\n  }\n}\n"],"names":[],"mappings":";;;;AAiBA,MAAM,gBAAA,GAAmB,SAAA;AAElB,MAAM,oBAAoB,sBAAA,CAAuB,gBAAA,EAAkB,MAAM,IAAI,wBAAwB;AAE5G,MAAM,uBAAuB,MAAM;AACjC,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,iBAAA,EAAkB;AAAA,IACpB;AAAA,GACF;AACF,CAAA,CAAA;AAkBO,MAAM,kBAAA,GAAqB,kBAAkB,mBAAmB;AAGvE,SAAS,sBAAA,CAAuB,GAAA,EAAU,GAAA,EAAU,GAAA,EAAU,IAAA,EAAiB;AAC7E,EAAA,gBAAA,CAAiB,GAAA,EAAK;AAAA,IACpB,SAAA,EAAW;AAAA,MACT,OAAA,EAAS,KAAA;AAAA,MACT,IAAA,EAAM;AAAA;AACR,GACD,CAAA;AACD,EAAA,IAAA,CAAK,GAAG,CAAA;AACV;AAqBO,MAAM,wBAAA,GAA2B,CAAC,GAAA,KAA0B;AACjE,EAAA,GAAA,CAAI,IAAI,sBAAsB,CAAA;AAK9B,EAAA,MAAM,SAAS,SAAA,EAAU;AACzB,EAAA,IAAI,MAAA,EAAQ;AACV,IAAA,MAAA,CAAO,EAAA,CAAG,aAAa,CAAA,IAAA,KAAQ;AAC7B,MAAA,wBAAA,CAAyB,IAAI,CAAA;AAAA,IAC/B,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,eAAA,CAAgB,GAAA,CAAI,KAAK,SAAS,CAAA;AACpC;AAEA,SAAS,yBAAyB,IAAA,EAAkB;AAClD,EAAA,MAAM,UAAA,GAAa,UAAA,CAAW,IAAI,CAAA,CAAE,IAAA;AAGpC,EAAA,MAAM,IAAA,GAAO,WAAW,cAAc,CAAA;AAGtC,EAAA,IAAI,UAAA,CAAW,4BAA4B,CAAA,IAAK,CAAC,IAAA,EAAM;AACrD,IAAA;AAAA,EACF;AAEA,EAAA,IAAA,CAAK,aAAA,CAAc;AAAA,IACjB,CAAC,gCAAgC,GAAG,wBAAA;AAAA,IACpC,CAAC,4BAA4B,GAAG,CAAA,EAAG,IAAI,CAAA,QAAA;AAAA,GACxC,CAAA;AAGD,EAAA,MAAM,IAAA,GAAO,WAAW,cAAc,CAAA;AACtC,EAAA,IAAI,OAAO,SAAS,QAAA,EAAU;AAC5B,IAAA,IAAA,CAAK,WAAW,IAAI,CAAA;AAAA,EACtB;AACF;;;;"}

package/build/esm/integrations/tracing/connect/vendored/enums/AttributeNames.js

@@ -0,0 +1,18 @@
+var AttributeNames = /* @__PURE__ */ ((AttributeNames2) => {
+  AttributeNames2["CONNECT_TYPE"] = "connect.type";
+  AttributeNames2["CONNECT_NAME"] = "connect.name";
+  return AttributeNames2;
+})(AttributeNames || {});
+var ConnectTypes = /* @__PURE__ */ ((ConnectTypes2) => {
+  ConnectTypes2["MIDDLEWARE"] = "middleware";
+  ConnectTypes2["REQUEST_HANDLER"] = "request_handler";
+  return ConnectTypes2;
+})(ConnectTypes || {});
+var ConnectNames = /* @__PURE__ */ ((ConnectNames2) => {
+  ConnectNames2["MIDDLEWARE"] = "middleware";
+  ConnectNames2["REQUEST_HANDLER"] = "request handler";
+  return ConnectNames2;
+})(ConnectNames || {});
+
+export { AttributeNames, ConnectNames, ConnectTypes };
+//# sourceMappingURL=AttributeNames.js.map

package/build/esm/integrations/tracing/connect/vendored/enums/AttributeNames.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeNames.js","sources":["../../../../../../../src/integrations/tracing/connect/vendored/enums/AttributeNames.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-connect\n * - Upstream version: @opentelemetry/instrumentation-connect@0.61.0\n */\n/* eslint-disable */\n\nexport enum AttributeNames {\n  CONNECT_TYPE = 'connect.type',\n  CONNECT_NAME = 'connect.name',\n}\n\nexport enum ConnectTypes {\n  MIDDLEWARE = 'middleware',\n  REQUEST_HANDLER = 'request_handler',\n}\n\nexport enum ConnectNames {\n  MIDDLEWARE = 'middleware',\n  REQUEST_HANDLER = 'request handler',\n}\n"],"names":["AttributeNames","ConnectTypes","ConnectNames"],"mappings":"AAqBO,IAAK,cAAA,qBAAAA,eAAAA,KAAL;AACL,EAAAA,gBAAA,cAAA,CAAA,GAAe,cAAA;AACf,EAAAA,gBAAA,cAAA,CAAA,GAAe,cAAA;AAFL,EAAA,OAAAA,eAAAA;AAAA,CAAA,EAAA,cAAA,IAAA,EAAA;AAKL,IAAK,YAAA,qBAAAC,aAAAA,KAAL;AACL,EAAAA,cAAA,YAAA,CAAA,GAAa,YAAA;AACb,EAAAA,cAAA,iBAAA,CAAA,GAAkB,iBAAA;AAFR,EAAA,OAAAA,aAAAA;AAAA,CAAA,EAAA,YAAA,IAAA,EAAA;AAKL,IAAK,YAAA,qBAAAC,aAAAA,KAAL;AACL,EAAAA,cAAA,YAAA,CAAA,GAAa,YAAA;AACb,EAAAA,cAAA,iBAAA,CAAA,GAAkB,iBAAA;AAFR,EAAA,OAAAA,aAAAA;AAAA,CAAA,EAAA,YAAA,IAAA,EAAA;;;;"}

package/build/esm/integrations/tracing/connect/vendored/instrumentation.js

@@ -0,0 +1,145 @@
+import { context } from '@opentelemetry/api';
+import { getRPCMetadata, RPCType } from '@opentelemetry/core';
+import { ConnectTypes, ConnectNames, AttributeNames } from './enums/AttributeNames.js';
+import { SDK_VERSION } from '@sentry/core';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition, isWrapped } from '@opentelemetry/instrumentation';
+import { ATTR_HTTP_ROUTE } from '@opentelemetry/semantic-conventions';
+import { addNewStackLayer, replaceCurrentStackRoute, generateRoute } from './utils.js';
+
+const PACKAGE_NAME = "@sentry/instrumentation-connect";
+const ANONYMOUS_NAME = "anonymous";
+class ConnectInstrumentation extends InstrumentationBase {
+  constructor(config = {}) {
+    super(PACKAGE_NAME, SDK_VERSION, config);
+  }
+  init() {
+    return [
+      new InstrumentationNodeModuleDefinition("connect", [">=3.0.0 <4"], (moduleExports) => {
+        return this._patchConstructor(moduleExports);
+      })
+    ];
+  }
+  _patchApp(patchedApp) {
+    if (!isWrapped(patchedApp.use)) {
+      this._wrap(patchedApp, "use", this._patchUse.bind(this));
+    }
+    if (!isWrapped(patchedApp.handle)) {
+      this._wrap(patchedApp, "handle", this._patchHandle.bind(this));
+    }
+  }
+  _patchConstructor(original) {
+    const instrumentation = this;
+    return function(...args) {
+      const app = original.apply(this, args);
+      instrumentation._patchApp(app);
+      return app;
+    };
+  }
+  _patchNext(next, finishSpan) {
+    return function nextFunction(err) {
+      const result = next.apply(this, [err]);
+      finishSpan();
+      return result;
+    };
+  }
+  _startSpan(routeName, middleWare) {
+    let connectType;
+    let connectName;
+    let connectTypeName;
+    if (routeName) {
+      connectType = ConnectTypes.REQUEST_HANDLER;
+      connectTypeName = ConnectNames.REQUEST_HANDLER;
+      connectName = routeName;
+    } else {
+      connectType = ConnectTypes.MIDDLEWARE;
+      connectTypeName = ConnectNames.MIDDLEWARE;
+      connectName = middleWare.name || ANONYMOUS_NAME;
+    }
+    const spanName = `${connectTypeName} - ${connectName}`;
+    const options = {
+      attributes: {
+        [ATTR_HTTP_ROUTE]: routeName.length > 0 ? routeName : "/",
+        [AttributeNames.CONNECT_TYPE]: connectType,
+        [AttributeNames.CONNECT_NAME]: connectName
+      }
+    };
+    return this.tracer.startSpan(spanName, options);
+  }
+  _patchMiddleware(routeName, middleWare) {
+    const instrumentation = this;
+    const isErrorMiddleware = middleWare.length === 4;
+    function patchedMiddleware() {
+      if (!instrumentation.isEnabled()) {
+        return middleWare.apply(this, arguments);
+      }
+      const [reqArgIdx, resArgIdx, nextArgIdx] = isErrorMiddleware ? [1, 2, 3] : [0, 1, 2];
+      const req = arguments[reqArgIdx];
+      const res = arguments[resArgIdx];
+      const next = arguments[nextArgIdx];
+      replaceCurrentStackRoute(req, routeName);
+      const rpcMetadata = getRPCMetadata(context.active());
+      if (routeName && rpcMetadata?.type === RPCType.HTTP) {
+        rpcMetadata.route = generateRoute(req);
+      }
+      let spanName = "";
+      if (routeName) {
+        spanName = `request handler - ${routeName}`;
+      } else {
+        spanName = `middleware - ${middleWare.name || ANONYMOUS_NAME}`;
+      }
+      const span = instrumentation._startSpan(routeName, middleWare);
+      instrumentation._diag.debug("start span", spanName);
+      let spanFinished = false;
+      function finishSpan() {
+        if (!spanFinished) {
+          spanFinished = true;
+          instrumentation._diag.debug(`finishing span ${span.name}`);
+          span.end();
+        } else {
+          instrumentation._diag.debug(`span ${span.name} - already finished`);
+        }
+        res.removeListener("close", finishSpan);
+      }
+      res.addListener("close", finishSpan);
+      arguments[nextArgIdx] = instrumentation._patchNext(next, finishSpan);
+      return middleWare.apply(this, arguments);
+    }
+    Object.defineProperty(patchedMiddleware, "length", {
+      value: middleWare.length,
+      writable: false,
+      configurable: true
+    });
+    return patchedMiddleware;
+  }
+  _patchUse(original) {
+    const instrumentation = this;
+    return function(...args) {
+      const middleWare = args[args.length - 1];
+      const routeName = args[args.length - 2] || "";
+      args[args.length - 1] = instrumentation._patchMiddleware(routeName, middleWare);
+      return original.apply(this, args);
+    };
+  }
+  _patchHandle(original) {
+    const instrumentation = this;
+    return function() {
+      const [reqIdx, outIdx] = [0, 2];
+      const req = arguments[reqIdx];
+      const out = arguments[outIdx];
+      const completeStack = addNewStackLayer(req);
+      if (typeof out === "function") {
+        arguments[outIdx] = instrumentation._patchOut(out, completeStack);
+      }
+      return original.apply(this, arguments);
+    };
+  }
+  _patchOut(out, completeStack) {
+    return function nextFunction(...args) {
+      completeStack();
+      return Reflect.apply(out, this, args);
+    };
+  }
+}
+
+export { ANONYMOUS_NAME, ConnectInstrumentation };
+//# sourceMappingURL=instrumentation.js.map

package/build/esm/integrations/tracing/connect/vendored/instrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.js","sources":["../../../../../../src/integrations/tracing/connect/vendored/instrumentation.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-connect\n * - Upstream version: @opentelemetry/instrumentation-connect@0.61.0\n * - Minor TypeScript strictness adjustments for this repository's compiler settings\n */\n/* eslint-disable */\n\nimport { context, Span, SpanOptions } from '@opentelemetry/api';\nimport { getRPCMetadata, RPCType } from '@opentelemetry/core';\nimport type { ServerResponse } from 'http';\nimport { AttributeNames, ConnectNames, ConnectTypes } from './enums/AttributeNames';\nimport { HandleFunction, NextFunction, Server, PatchedRequest, Use, UseArgs, UseArgs2 } from './internal-types';\nimport { SDK_VERSION } from '@sentry/core';\nimport {\n  InstrumentationBase,\n  InstrumentationConfig,\n  InstrumentationNodeModuleDefinition,\n  isWrapped,\n} from '@opentelemetry/instrumentation';\nimport { ATTR_HTTP_ROUTE } from '@opentelemetry/semantic-conventions';\nimport { replaceCurrentStackRoute, addNewStackLayer, generateRoute } from './utils';\n\nconst PACKAGE_NAME = '@sentry/instrumentation-connect';\n\nexport const ANONYMOUS_NAME = 'anonymous';\n\n/** Connect instrumentation for OpenTelemetry */\nexport class ConnectInstrumentation extends InstrumentationBase {\n  constructor(config: InstrumentationConfig = {}) {\n    super(PACKAGE_NAME, SDK_VERSION, config);\n  }\n\n  init() {\n    return [\n      new InstrumentationNodeModuleDefinition('connect', ['>=3.0.0 <4'], moduleExports => {\n        return this._patchConstructor(moduleExports);\n      }),\n    ];\n  }\n\n  private _patchApp(patchedApp: Server) {\n    if (!isWrapped(patchedApp.use)) {\n      this._wrap(patchedApp, 'use', this._patchUse.bind(this));\n    }\n    if (!isWrapped(patchedApp.handle)) {\n      this._wrap(patchedApp, 'handle', this._patchHandle.bind(this));\n    }\n  }\n\n  private _patchConstructor(original: () => Server): () => Server {\n    const instrumentation = this;\n    return function (this: Server, ...args: any[]) {\n      const app = original.apply(this, args) as Server;\n      instrumentation._patchApp(app);\n      return app;\n    };\n  }\n\n  public _patchNext(next: NextFunction, finishSpan: () => void): NextFunction {\n    return function nextFunction(this: NextFunction, err?: any): void {\n      const result = next.apply(this, [err]);\n      finishSpan();\n      return result;\n    };\n  }\n\n  public _startSpan(routeName: string, middleWare: HandleFunction): Span {\n    let connectType: ConnectTypes;\n    let connectName: string;\n    let connectTypeName: string;\n    if (routeName) {\n      connectType = ConnectTypes.REQUEST_HANDLER;\n      connectTypeName = ConnectNames.REQUEST_HANDLER;\n      connectName = routeName;\n    } else {\n      connectType = ConnectTypes.MIDDLEWARE;\n      connectTypeName = ConnectNames.MIDDLEWARE;\n      connectName = middleWare.name || ANONYMOUS_NAME;\n    }\n    const spanName = `${connectTypeName} - ${connectName}`;\n    const options: SpanOptions = {\n      attributes: {\n        [ATTR_HTTP_ROUTE]: routeName.length > 0 ? routeName : '/',\n        [AttributeNames.CONNECT_TYPE]: connectType,\n        [AttributeNames.CONNECT_NAME]: connectName,\n      },\n    };\n\n    return this.tracer.startSpan(spanName, options);\n  }\n\n  public _patchMiddleware(routeName: string, middleWare: HandleFunction): HandleFunction {\n    const instrumentation = this;\n    const isErrorMiddleware = middleWare.length === 4;\n\n    function patchedMiddleware(this: Use): void {\n      if (!instrumentation.isEnabled()) {\n        return (middleWare as any).apply(this, arguments);\n      }\n      const [reqArgIdx, resArgIdx, nextArgIdx] = isErrorMiddleware ? [1, 2, 3] : [0, 1, 2];\n      const req = arguments[reqArgIdx] as PatchedRequest;\n      const res = arguments[resArgIdx] as ServerResponse;\n      const next = arguments[nextArgIdx] as NextFunction;\n\n      replaceCurrentStackRoute(req, routeName);\n\n      const rpcMetadata = getRPCMetadata(context.active());\n      if (routeName && rpcMetadata?.type === RPCType.HTTP) {\n        rpcMetadata.route = generateRoute(req);\n      }\n\n      let spanName = '';\n      if (routeName) {\n        spanName = `request handler - ${routeName}`;\n      } else {\n        spanName = `middleware - ${middleWare.name || ANONYMOUS_NAME}`;\n      }\n      const span = instrumentation._startSpan(routeName, middleWare);\n      instrumentation._diag.debug('start span', spanName);\n      let spanFinished = false;\n\n      function finishSpan() {\n        if (!spanFinished) {\n          spanFinished = true;\n          instrumentation._diag.debug(`finishing span ${(span as any).name}`);\n          span.end();\n        } else {\n          instrumentation._diag.debug(`span ${(span as any).name} - already finished`);\n        }\n        res.removeListener('close', finishSpan);\n      }\n\n      res.addListener('close', finishSpan);\n      arguments[nextArgIdx] = instrumentation._patchNext(next, finishSpan);\n\n      return (middleWare as any).apply(this, arguments);\n    }\n\n    Object.defineProperty(patchedMiddleware, 'length', {\n      value: middleWare.length,\n      writable: false,\n      configurable: true,\n    });\n\n    return patchedMiddleware;\n  }\n\n  public _patchUse(original: Server['use']): Use {\n    const instrumentation = this;\n    return function (this: Server, ...args: UseArgs): Server {\n      const middleWare = args[args.length - 1] as HandleFunction;\n      const routeName = (args[args.length - 2] || '') as string;\n\n      args[args.length - 1] = instrumentation._patchMiddleware(routeName, middleWare);\n\n      return original.apply(this, args as UseArgs2);\n    };\n  }\n\n  public _patchHandle(original: Server['handle']): Server['handle'] {\n    const instrumentation = this;\n    return function (this: Server): ReturnType<Server['handle']> {\n      const [reqIdx, outIdx] = [0, 2];\n      const req = arguments[reqIdx] as PatchedRequest;\n      const out = arguments[outIdx];\n      const completeStack = addNewStackLayer(req);\n\n      if (typeof out === 'function') {\n        arguments[outIdx] = instrumentation._patchOut(out as NextFunction, completeStack);\n      }\n\n      return (original as any).apply(this, arguments);\n    };\n  }\n\n  public _patchOut(out: NextFunction, completeStack: () => void): NextFunction {\n    return function nextFunction(this: NextFunction, ...args: any[]): void {\n      completeStack();\n      return Reflect.apply(out, this, args);\n    };\n  }\n}\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/tracing/connect/vendored/internal-types.js

@@ -0,0 +1,6 @@
+const _LAYERS_STORE_PROPERTY = /* @__PURE__ */ Symbol(
+  "opentelemetry.instrumentation-connect.request-route-stack"
+);
+
+export { _LAYERS_STORE_PROPERTY };
+//# sourceMappingURL=internal-types.js.map

package/build/esm/integrations/tracing/connect/vendored/internal-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-types.js","sources":["../../../../../../src/integrations/tracing/connect/vendored/internal-types.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-connect\n * - Upstream version: @opentelemetry/instrumentation-connect@0.61.0\n * - Some types vendored from @types/connect\n */\n/* eslint-disable */\n\nimport type * as http from 'http';\n\nexport type IncomingMessage = http.IncomingMessage & {\n  originalUrl?: http.IncomingMessage['url'] | undefined;\n};\n\nexport type NextFunction = (err?: any) => void;\n\nexport type SimpleHandleFunction = (req: IncomingMessage, res: http.ServerResponse) => void;\nexport type NextHandleFunction = (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;\nexport type ErrorHandleFunction = (\n  err: any,\n  req: IncomingMessage,\n  res: http.ServerResponse,\n  next: NextFunction,\n) => void;\nexport type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;\n\nexport interface Server extends NodeJS.EventEmitter {\n  (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;\n\n  route: string;\n  stack: Array<{ route: string; handle: HandleFunction | http.Server }>;\n\n  use(fn: NextHandleFunction): Server;\n  use(fn: HandleFunction): Server;\n  use(route: string, fn: NextHandleFunction): Server;\n  use(route: string, fn: HandleFunction): Server;\n\n  handle(req: http.IncomingMessage, res: http.ServerResponse, next: Function): void;\n}\n\nexport const _LAYERS_STORE_PROPERTY: unique symbol = Symbol(\n  'opentelemetry.instrumentation-connect.request-route-stack',\n);\n\nexport type UseArgs1 = [HandleFunction];\nexport type UseArgs2 = [string, HandleFunction];\nexport type UseArgs = UseArgs1 | UseArgs2;\nexport type Use = (...args: UseArgs) => Server;\nexport type PatchedRequest = {\n  [_LAYERS_STORE_PROPERTY]: string[];\n} & IncomingMessage;\n"],"names":[],"mappings":"AAsDO,MAAM,sBAAA,mBAAwC,MAAA;AAAA,EACnD;AACF;;;;"}

package/build/esm/integrations/tracing/connect/vendored/utils.js

@@ -0,0 +1,31 @@
+import { diag } from '@opentelemetry/api';
+import { _LAYERS_STORE_PROPERTY } from './internal-types.js';
+
+const addNewStackLayer = (request) => {
+  if (Array.isArray(request[_LAYERS_STORE_PROPERTY]) === false) {
+    Object.defineProperty(request, _LAYERS_STORE_PROPERTY, {
+      enumerable: false,
+      value: []
+    });
+  }
+  request[_LAYERS_STORE_PROPERTY].push("/");
+  const stackLength = request[_LAYERS_STORE_PROPERTY].length;
+  return () => {
+    if (stackLength === request[_LAYERS_STORE_PROPERTY].length) {
+      request[_LAYERS_STORE_PROPERTY].pop();
+    } else {
+      diag.warn("Connect: Trying to pop the stack multiple time");
+    }
+  };
+};
+const replaceCurrentStackRoute = (request, newRoute) => {
+  if (newRoute) {
+    request[_LAYERS_STORE_PROPERTY].splice(-1, 1, newRoute);
+  }
+};
+const generateRoute = (request) => {
+  return request[_LAYERS_STORE_PROPERTY].reduce((acc, sub) => acc.replace(/\/+$/, "") + sub);
+};
+
+export { addNewStackLayer, generateRoute, replaceCurrentStackRoute };
+//# sourceMappingURL=utils.js.map

package/build/esm/integrations/tracing/connect/vendored/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../src/integrations/tracing/connect/vendored/utils.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-connect\n * - Upstream version: @opentelemetry/instrumentation-connect@0.61.0\n */\n/* eslint-disable */\n\nimport { diag } from '@opentelemetry/api';\nimport { _LAYERS_STORE_PROPERTY, PatchedRequest } from './internal-types';\n\nexport const addNewStackLayer = (request: PatchedRequest) => {\n  if (Array.isArray(request[_LAYERS_STORE_PROPERTY]) === false) {\n    Object.defineProperty(request, _LAYERS_STORE_PROPERTY, {\n      enumerable: false,\n      value: [],\n    });\n  }\n  request[_LAYERS_STORE_PROPERTY].push('/');\n\n  const stackLength = request[_LAYERS_STORE_PROPERTY].length;\n\n  return () => {\n    if (stackLength === request[_LAYERS_STORE_PROPERTY].length) {\n      request[_LAYERS_STORE_PROPERTY].pop();\n    } else {\n      diag.warn('Connect: Trying to pop the stack multiple time');\n    }\n  };\n};\n\nexport const replaceCurrentStackRoute = (request: PatchedRequest, newRoute?: string) => {\n  if (newRoute) {\n    request[_LAYERS_STORE_PROPERTY].splice(-1, 1, newRoute);\n  }\n};\n\n// generate route from existing stack on request object.\n// splash between stack layer will be deduped\n// [\"/first/\", \"/second\", \"/third/\"] => /first/second/third/\nexport const generateRoute = (request: PatchedRequest) => {\n  return request[_LAYERS_STORE_PROPERTY].reduce((acc, sub) => acc.replace(/\\/+$/, '') + sub);\n};\n"],"names":[],"mappings":";;;AAwBO,MAAM,gBAAA,GAAmB,CAAC,OAAA,KAA4B;AAC3D,EAAA,IAAI,MAAM,OAAA,CAAQ,OAAA,CAAQ,sBAAsB,CAAC,MAAM,KAAA,EAAO;AAC5D,IAAA,MAAA,CAAO,cAAA,CAAe,SAAS,sBAAA,EAAwB;AAAA,MACrD,UAAA,EAAY,KAAA;AAAA,MACZ,OAAO;AAAC,KACT,CAAA;AAAA,EACH;AACA,EAAA,OAAA,CAAQ,sBAAsB,CAAA,CAAE,IAAA,CAAK,GAAG,CAAA;AAExC,EAAA,MAAM,WAAA,GAAc,OAAA,CAAQ,sBAAsB,CAAA,CAAE,MAAA;AAEpD,EAAA,OAAO,MAAM;AACX,IAAA,IAAI,WAAA,KAAgB,OAAA,CAAQ,sBAAsB,CAAA,CAAE,MAAA,EAAQ;AAC1D,MAAA,OAAA,CAAQ,sBAAsB,EAAE,GAAA,EAAI;AAAA,IACtC,CAAA,MAAO;AACL,MAAA,IAAA,CAAK,KAAK,gDAAgD,CAAA;AAAA,IAC5D;AAAA,EACF,CAAA;AACF;AAEO,MAAM,wBAAA,GAA2B,CAAC,OAAA,EAAyB,QAAA,KAAsB;AACtF,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,OAAA,CAAQ,sBAAsB,CAAA,CAAE,MAAA,CAAO,EAAA,EAAI,GAAG,QAAQ,CAAA;AAAA,EACxD;AACF;AAKO,MAAM,aAAA,GAAgB,CAAC,OAAA,KAA4B;AACxD,EAAA,OAAO,OAAA,CAAQ,sBAAsB,CAAA,CAAE,MAAA,CAAO,CAAC,GAAA,EAAK,GAAA,KAAQ,GAAA,CAAI,OAAA,CAAQ,MAAA,EAAQ,EAAE,CAAA,GAAI,GAAG,CAAA;AAC3F;;;;"}

package/build/esm/integrations/tracing/dataloader/index.js

@@ -0,0 +1,38 @@
+import { DataloaderInstrumentation } from './vendored/instrumentation.js';
+import { defineIntegration, spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP } from '@sentry/core';
+import { generateInstrumentOnce, instrumentWhenWrapped } from '@sentry/node-core';
+
+const INTEGRATION_NAME = "Dataloader";
+const instrumentDataloader = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  () => new DataloaderInstrumentation({
+    requireParentSpan: true
+  })
+);
+const _dataloaderIntegration = (() => {
+  let instrumentationWrappedCallback;
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      const instrumentation = instrumentDataloader();
+      instrumentationWrappedCallback = instrumentWhenWrapped(instrumentation);
+    },
+    setup(client) {
+      instrumentationWrappedCallback?.(() => {
+        client.on("spanStart", (span) => {
+          const spanJSON = spanToJSON(span);
+          if (spanJSON.description?.startsWith("dataloader")) {
+            span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, "auto.db.otel.dataloader");
+          }
+          if (spanJSON.description === "dataloader.load" || spanJSON.description === "dataloader.loadMany" || spanJSON.description === "dataloader.batch") {
+            span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, "cache.get");
+          }
+        });
+      });
+    }
+  };
+});
+const dataloaderIntegration = defineIntegration(_dataloaderIntegration);
+
+export { dataloaderIntegration, instrumentDataloader };
+//# sourceMappingURL=index.js.map

package/build/esm/integrations/tracing/dataloader/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/dataloader/index.ts"],"sourcesContent":["import { DataloaderInstrumentation } from './vendored/instrumentation';\nimport type { IntegrationFn } from '@sentry/core';\nimport {\n  defineIntegration,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  spanToJSON,\n} from '@sentry/core';\nimport { generateInstrumentOnce, instrumentWhenWrapped } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'Dataloader';\n\nexport const instrumentDataloader = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  () =>\n    new DataloaderInstrumentation({\n      requireParentSpan: true,\n    }),\n);\n\nconst _dataloaderIntegration = (() => {\n  let instrumentationWrappedCallback: undefined | ((callback: () => void) => void);\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      const instrumentation = instrumentDataloader();\n      instrumentationWrappedCallback = instrumentWhenWrapped(instrumentation);\n    },\n\n    setup(client) {\n      // This is called either immediately or when the instrumentation is wrapped\n      instrumentationWrappedCallback?.(() => {\n        client.on('spanStart', span => {\n          const spanJSON = spanToJSON(span);\n          if (spanJSON.description?.startsWith('dataloader')) {\n            span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.db.otel.dataloader');\n          }\n\n          // These are all possible dataloader span descriptions\n          // Still checking for the future versions\n          // in case they add support for `clear` and `prime`\n          if (\n            spanJSON.description === 'dataloader.load' ||\n            spanJSON.description === 'dataloader.loadMany' ||\n            spanJSON.description === 'dataloader.batch'\n          ) {\n            span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'cache.get');\n            // TODO: We can try adding `key` to the `data` attribute upstream.\n            // Or alternatively, we can add `requestHook` to the dataloader instrumentation.\n          }\n        });\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [dataloader](https://www.npmjs.com/package/dataloader) library.\n *\n * For more information, see the [`dataloaderIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/dataloader/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.dataloaderIntegration()],\n * });\n * ```\n */\nexport const dataloaderIntegration = defineIntegration(_dataloaderIntegration);\n"],"names":[],"mappings":";;;;AAUA,MAAM,gBAAA,GAAmB,YAAA;AAElB,MAAM,oBAAA,GAAuB,sBAAA;AAAA,EAClC,gBAAA;AAAA,EACA,MACE,IAAI,yBAAA,CAA0B;AAAA,IAC5B,iBAAA,EAAmB;AAAA,GACpB;AACL;AAEA,MAAM,0BAA0B,MAAM;AACpC,EAAA,IAAI,8BAAA;AAEJ,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,MAAM,kBAAkB,oBAAA,EAAqB;AAC7C,MAAA,8BAAA,GAAiC,sBAAsB,eAAe,CAAA;AAAA,IACxE,CAAA;AAAA,IAEA,MAAM,MAAA,EAAQ;AAEZ,MAAA,8BAAA,GAAiC,MAAM;AACrC,QAAA,MAAA,CAAO,EAAA,CAAG,aAAa,CAAA,IAAA,KAAQ;AAC7B,UAAA,MAAM,QAAA,GAAW,WAAW,IAAI,CAAA;AAChC,UAAA,IAAI,QAAA,CAAS,WAAA,EAAa,UAAA,CAAW,YAAY,CAAA,EAAG;AAClD,YAAA,IAAA,CAAK,YAAA,CAAa,kCAAkC,yBAAyB,CAAA;AAAA,UAC/E;AAKA,UAAA,IACE,QAAA,CAAS,gBAAgB,iBAAA,IACzB,QAAA,CAAS,gBAAgB,qBAAA,IACzB,QAAA,CAAS,gBAAgB,kBAAA,EACzB;AACA,YAAA,IAAA,CAAK,YAAA,CAAa,8BAA8B,WAAW,CAAA;AAAA,UAG7D;AAAA,QACF,CAAC,CAAA;AAAA,MACH,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAgBO,MAAM,qBAAA,GAAwB,kBAAkB,sBAAsB;;;;"}

package/build/esm/integrations/tracing/dataloader/vendored/instrumentation.js

@@ -0,0 +1,243 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition, isWrapped } from '@opentelemetry/instrumentation';
+import { trace, context, SpanStatusCode, SpanKind } from '@opentelemetry/api';
+import { SDK_VERSION } from '@sentry/core';
+
+const MODULE_NAME = "dataloader";
+const PACKAGE_NAME = "@sentry/instrumentation-dataloader";
+function extractModuleExports(module) {
+  return module[Symbol.toStringTag] === "Module" ? module.default : module;
+}
+class DataloaderInstrumentation extends InstrumentationBase {
+  constructor(config = {}) {
+    super(PACKAGE_NAME, SDK_VERSION, config);
+  }
+  init() {
+    return [
+      new InstrumentationNodeModuleDefinition(
+        MODULE_NAME,
+        [">=2.0.0 <3"],
+        (module) => {
+          const dataloader = extractModuleExports(module);
+          this._patchLoad(dataloader.prototype);
+          this._patchLoadMany(dataloader.prototype);
+          this._patchPrime(dataloader.prototype);
+          this._patchClear(dataloader.prototype);
+          this._patchClearAll(dataloader.prototype);
+          return this._getPatchedConstructor(dataloader);
+        },
+        (module) => {
+          const dataloader = extractModuleExports(module);
+          ["load", "loadMany", "prime", "clear", "clearAll"].forEach((method) => {
+            if (isWrapped(dataloader.prototype[method])) {
+              this._unwrap(dataloader.prototype, method);
+            }
+          });
+        }
+      )
+    ];
+  }
+  shouldCreateSpans() {
+    const config = this.getConfig();
+    const hasParentSpan = trace.getSpan(context.active()) !== void 0;
+    return hasParentSpan || !config.requireParentSpan;
+  }
+  getSpanName(dataloader, operation) {
+    const dataloaderName = dataloader.name;
+    if (dataloaderName === void 0 || dataloaderName === null) {
+      return `${MODULE_NAME}.${operation}`;
+    }
+    return `${MODULE_NAME}.${operation} ${dataloaderName}`;
+  }
+  _wrapBatchLoadFn(batchLoadFn) {
+    const instrumentation = this;
+    return function patchedBatchLoadFn(...args) {
+      if (!instrumentation.isEnabled() || !instrumentation.shouldCreateSpans()) {
+        return batchLoadFn.call(this, ...args);
+      }
+      const parent = context.active();
+      const span = instrumentation.tracer.startSpan(
+        instrumentation.getSpanName(this, "batch"),
+        { links: this._batch?.spanLinks },
+        parent
+      );
+      return context.with(trace.setSpan(parent, span), () => {
+        return batchLoadFn.apply(this, args).then((value) => {
+          span.end();
+          return value;
+        }).catch((err) => {
+          span.recordException(err);
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: err.message
+          });
+          span.end();
+          throw err;
+        });
+      });
+    };
+  }
+  _getPatchedConstructor(constructor) {
+    const instrumentation = this;
+    const prototype = constructor.prototype;
+    if (!instrumentation.isEnabled()) {
+      return constructor;
+    }
+    function PatchedDataloader(...args) {
+      if (typeof args[0] === "function") {
+        if (isWrapped(args[0])) {
+          instrumentation._unwrap(args, 0);
+        }
+        args[0] = instrumentation._wrapBatchLoadFn(args[0]);
+      }
+      return constructor.apply(this, args);
+    }
+    PatchedDataloader.prototype = prototype;
+    return PatchedDataloader;
+  }
+  _patchLoad(proto) {
+    if (isWrapped(proto.load)) {
+      this._unwrap(proto, "load");
+    }
+    this._wrap(proto, "load", this._getPatchedLoad.bind(this));
+  }
+  _getPatchedLoad(original) {
+    const instrumentation = this;
+    return function patchedLoad(...args) {
+      if (!instrumentation.shouldCreateSpans()) {
+        return original.call(this, ...args);
+      }
+      const parent = context.active();
+      const span = instrumentation.tracer.startSpan(
+        instrumentation.getSpanName(this, "load"),
+        { kind: SpanKind.CLIENT },
+        parent
+      );
+      return context.with(trace.setSpan(parent, span), () => {
+        const result = original.call(this, ...args).then((value) => {
+          span.end();
+          return value;
+        }).catch((err) => {
+          span.recordException(err);
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: err.message
+          });
+          span.end();
+          throw err;
+        });
+        const loader = this;
+        if (loader._batch) {
+          if (!loader._batch.spanLinks) {
+            loader._batch.spanLinks = [];
+          }
+          loader._batch.spanLinks.push({ context: span.spanContext() });
+        }
+        return result;
+      });
+    };
+  }
+  _patchLoadMany(proto) {
+    if (isWrapped(proto.loadMany)) {
+      this._unwrap(proto, "loadMany");
+    }
+    this._wrap(proto, "loadMany", this._getPatchedLoadMany.bind(this));
+  }
+  _getPatchedLoadMany(original) {
+    const instrumentation = this;
+    return function patchedLoadMany(...args) {
+      if (!instrumentation.shouldCreateSpans()) {
+        return original.call(this, ...args);
+      }
+      const parent = context.active();
+      const span = instrumentation.tracer.startSpan(
+        instrumentation.getSpanName(this, "loadMany"),
+        { kind: SpanKind.CLIENT },
+        parent
+      );
+      return context.with(trace.setSpan(parent, span), () => {
+        return original.call(this, ...args).then((value) => {
+          span.end();
+          return value;
+        });
+      });
+    };
+  }
+  _patchPrime(proto) {
+    if (isWrapped(proto.prime)) {
+      this._unwrap(proto, "prime");
+    }
+    this._wrap(proto, "prime", this._getPatchedPrime.bind(this));
+  }
+  _getPatchedPrime(original) {
+    const instrumentation = this;
+    return function patchedPrime(...args) {
+      if (!instrumentation.shouldCreateSpans()) {
+        return original.call(this, ...args);
+      }
+      const parent = context.active();
+      const span = instrumentation.tracer.startSpan(
+        instrumentation.getSpanName(this, "prime"),
+        { kind: SpanKind.CLIENT },
+        parent
+      );
+      const ret = context.with(trace.setSpan(parent, span), () => {
+        return original.call(this, ...args);
+      });
+      span.end();
+      return ret;
+    };
+  }
+  _patchClear(proto) {
+    if (isWrapped(proto.clear)) {
+      this._unwrap(proto, "clear");
+    }
+    this._wrap(proto, "clear", this._getPatchedClear.bind(this));
+  }
+  _getPatchedClear(original) {
+    const instrumentation = this;
+    return function patchedClear(...args) {
+      if (!instrumentation.shouldCreateSpans()) {
+        return original.call(this, ...args);
+      }
+      const parent = context.active();
+      const span = instrumentation.tracer.startSpan(
+        instrumentation.getSpanName(this, "clear"),
+        { kind: SpanKind.CLIENT },
+        parent
+      );
+      const ret = context.with(trace.setSpan(parent, span), () => {
+        return original.call(this, ...args);
+      });
+      span.end();
+      return ret;
+    };
+  }
+  _patchClearAll(proto) {
+    if (isWrapped(proto.clearAll)) {
+      this._unwrap(proto, "clearAll");
+    }
+    this._wrap(proto, "clearAll", this._getPatchedClearAll.bind(this));
+  }
+  _getPatchedClearAll(original) {
+    const instrumentation = this;
+    return function patchedClearAll(...args) {
+      if (!instrumentation.shouldCreateSpans()) {
+        return original.call(this, ...args);
+      }
+      const parent = context.active();
+      const span = instrumentation.tracer.startSpan(
+        instrumentation.getSpanName(this, "clearAll"),
+        { kind: SpanKind.CLIENT },
+        parent
+      );
+      const ret = context.with(trace.setSpan(parent, span), () => {
+        return original.call(this, ...args);
+      });
+      span.end();
+      return ret;
+    };
+  }
+}
+
+export { DataloaderInstrumentation };
+//# sourceMappingURL=instrumentation.js.map