@sentry/node 8.37.1 → 8.39.0-dev.0

package/build/types/integrations/tracing/mysql.d.ts

@@ -1,15 +1,33 @@
 export declare const instrumentMysql: ((options?: unknown) => void) & {
     /**
-     * MySQL integration
+     * Adds Sentry tracing instrumentation for the [mysql](https://www.npmjs.com/package/mysql) library.
      *
-     * Capture tracing data for mysql.
+     * For more information, see the [`mysqlIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mysql/).
+     *
+     * @example
+     * ```javascript
+     * const Sentry = require('@sentry/node');
+     *
+     * Sentry.init({
+     *  integrations: [Sentry.mysqlIntegration()],
+     * });
+     * ```
      */
     id: string;
 };
 /**
- * MySQL integration
+ * Adds Sentry tracing instrumentation for the [mysql](https://www.npmjs.com/package/mysql) library.
+ *
+ * For more information, see the [`mysqlIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mysql/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
  *
- * Capture tracing data for mysql.
+ * Sentry.init({
+ *  integrations: [Sentry.mysqlIntegration()],
+ * });
+ * ```
  */
 export declare const mysqlIntegration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=mysql.d.ts.map

package/build/types/integrations/tracing/mysql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/mysql.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,eAAe;IAW5B;;;;OAIG;;CAfwG,CAAC;AAW5G;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,2CAAuC,CAAC"}
+{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/mysql.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,eAAe;IAW5B;;;;;;;;;;;;;OAaG;;CAxBwG,CAAC;AAW5G;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,2CAAuC,CAAC"}

package/build/types/integrations/tracing/mysql2.d.ts

@@ -2,9 +2,18 @@ export declare const instrumentMysql2: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * MySQL2 integration
+ * Adds Sentry tracing instrumentation for the [mysql2](https://www.npmjs.com/package/mysql2) library.
  *
- * Capture tracing data for mysql2
+ * For more information, see the [`mysql2Integration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mysql2/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mysqlIntegration()],
+ * });
+ * ```
  */
 export declare const mysql2Integration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=mysql2.d.ts.map

package/build/types/integrations/tracing/mysql2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mysql2.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/mysql2.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,gBAAgB;;CAQ5B,CAAC;AAWF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,2CAAwC,CAAC"}
+{"version":3,"file":"mysql2.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/mysql2.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,gBAAgB;;CAQ5B,CAAC;AAWF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,2CAAwC,CAAC"}

package/build/types/integrations/tracing/postgres.d.ts

@@ -2,9 +2,18 @@ export declare const instrumentPostgres: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * Postgres integration
+ * Adds Sentry tracing instrumentation for the [pg](https://www.npmjs.com/package/pg) library.
  *
- * Capture tracing data for pg.
+ * For more information, see the [`postgresIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/postgres/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.postgresIntegration()],
+ * });
+ * ```
  */
 export declare const postgresIntegration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=postgres.d.ts.map

package/build/types/integrations/tracing/postgres.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/postgres.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,kBAAkB;;CAS9B,CAAC;AAWF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,2CAA0C,CAAC"}
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/postgres.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,kBAAkB;;CAS9B,CAAC;AAWF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,2CAA0C,CAAC"}

package/build/types/integrations/tracing/prisma.d.ts

@@ -2,13 +2,31 @@ export declare const instrumentPrisma: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * Prisma integration
+ * Adds Sentry tracing instrumentation for the [prisma](https://www.npmjs.com/package/prisma) library.
  *
- * Capture tracing data for prisma.
- * Note: This requires to set:
- * previewFeatures = ["tracing"]
- * For the prisma client.
- * See https://www.prisma.io/docs/concepts/components/prisma-client/opentelemetry-tracing for more details.
+ * For more information, see the [`prismaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/prisma/).
+ *
+ * @example
+ *
+ * Make sure `previewFeatures = ["tracing"]` is set in the prisma client generator block. See the
+ * [prisma docs](https://www.prisma.io/docs/concepts/components/prisma-client/opentelemetry-tracing) for more details.
+ *
+ * ```prisma
+ * generator client {
+ *  provider = "prisma-client-js"
+ *  previewFeatures = ["tracing"]
+ * }
+ * ```
+ *
+ * Then you can use the integration like this:
+ *
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.prismaIntegration()],
+ * });
+ * ```
  */
 export declare const prismaIntegration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=prisma.d.ts.map

package/build/types/integrations/tracing/prisma.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/prisma.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,gBAAgB;;CAO3B,CAAC;AAwBH;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,2CAAwC,CAAC"}
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/prisma.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,gBAAgB;;CAO3B,CAAC;AAwBH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iBAAiB,2CAAwC,CAAC"}

package/build/types/integrations/tracing/redis.d.ts

@@ -6,9 +6,19 @@ export declare const instrumentRedis: (() => void) & {
     id: string;
 };
 /**
- * Redis integration for "ioredis"
+ * Adds Sentry tracing instrumentation for the [redis](https://www.npmjs.com/package/redis) and
+ * [ioredis](https://www.npmjs.com/package/ioredis) libraries.
  *
- * Capture tracing data for redis and ioredis.
+ * For more information, see the [`redisIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/redis/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.redisIntegration()],
+ * });
+ * ```
  */
 export declare const redisIntegration: (options?: RedisOptions | undefined) => import("@sentry/types").Integration;
 export {};

package/build/types/integrations/tracing/redis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/redis.ts"],"names":[],"mappings":"AAyBA,UAAU,YAAY;IACpB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AA8DD,qJAAqJ;AACrJ,eAAO,MAAM,eAAe,SACtB,IAAI;;CAQT,CAAC;AAYF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,6EAAuC,CAAC"}
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/redis.ts"],"names":[],"mappings":"AAyBA,UAAU,YAAY;IACpB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AA8DD,qJAAqJ;AACrJ,eAAO,MAAM,eAAe,SACtB,IAAI;;CAQT,CAAC;AAYF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,6EAAuC,CAAC"}

package/build/types/integrations/tracing/tedious.d.ts

@@ -0,0 +1,19 @@
+export declare const instrumentTedious: ((options?: unknown) => void) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [tedious](https://www.npmjs.com/package/tedious) library.
+ *
+ * For more information, see the [`tediousIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/tedious/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.tediousIntegration()],
+ * });
+ * ```
+ */
+export declare const tediousIntegration: () => import("@sentry/types").Integration;
+//# sourceMappingURL=tedious.d.ts.map

package/build/types/integrations/tracing/tedious.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tedious.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/tedious.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,iBAAiB;;CAAiF,CAAC;AA0BhH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,2CAAyC,CAAC"}

package/build/types-ts3.8/index.d.ts

@@ -26,6 +26,8 @@ export { hapiIntegration, setupHapiErrorHandler } from './integrations/tracing/h
 export { koaIntegration, setupKoaErrorHandler } from './integrations/tracing/koa';
 export { connectIntegration, setupConnectErrorHandler } from './integrations/tracing/connect';
 export { spotlightIntegration } from './integrations/spotlight';
+export { knexIntegration } from './integrations/tracing/knex';
+export { tediousIntegration } from './integrations/tracing/tedious';
 export { genericPoolIntegration } from './integrations/tracing/genericPool';
 export { dataloaderIntegration } from './integrations/tracing/dataloader';
 export { amqplibIntegration } from './integrations/tracing/amqplib';

package/build/types-ts3.8/integrations/tracing/amqplib.d.ts

@@ -1,5 +1,19 @@
 export declare const instrumentAmqplib: ((options?: unknown) => void) & {
     id: string;
 };
+/**
+ * Adds Sentry tracing instrumentation for the [amqplib](https://www.npmjs.com/package/amqplib) library.
+ *
+ * For more information, see the [`amqplibIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/amqplib/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.amqplibIntegration()],
+ * });
+ * ```
+ */
 export declare const amqplibIntegration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=amqplib.d.ts.map

package/build/types-ts3.8/integrations/tracing/connect.d.ts

@@ -4,7 +4,42 @@ type ConnectApp = {
 export declare const instrumentConnect: ((options?: unknown) => void) & {
     id: string;
 };
+/**
+ * Adds Sentry tracing instrumentation for [Connect](https://github.com/senchalabs/connect/).
+ *
+ * If you also want to capture errors, you need to call `setupConnectErrorHandler(app)` after you initialize your connect app.
+ *
+ * For more information, see the [connect documentation](https://docs.sentry.io/platforms/javascript/guides/connect/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.connectIntegration()],
+ * })
+ * ```
+ */
 export declare const connectIntegration: () => import("@sentry/types").Integration;
+/**
+ * Add a Connect middleware to capture errors to Sentry.
+ *
+ * @param app The Connect app to attach the error handler to
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const connect = require("connect");
+ *
+ * const app = connect();
+ *
+ * Sentry.setupConnectErrorHandler(app);
+ *
+ * // Add you connect routes here
+ *
+ * app.listen(3000);
+ * ```
+ */
 export declare const setupConnectErrorHandler: (app: ConnectApp) => void;
 export {};
 //# sourceMappingURL=connect.d.ts.map

package/build/types-ts3.8/integrations/tracing/dataloader.d.ts

@@ -2,9 +2,18 @@ export declare const instrumentDataloader: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * Dataloader integration
+ * Adds Sentry tracing instrumentation for the [dataloader](https://www.npmjs.com/package/dataloader) library.
  *
- * Capture tracing data for Dataloader.
+ * For more information, see the [`dataloaderIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/dataloader/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.dataloaderIntegration()],
+ * });
+ * ```
  */
 export declare const dataloaderIntegration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=dataloader.d.ts.map

package/build/types-ts3.8/integrations/tracing/express.d.ts

@@ -4,10 +4,20 @@ export declare const instrumentExpress: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * Express integration
+ * Adds Sentry tracing instrumentation for [Express](https://expressjs.com/).
  *
- * Capture tracing data for express.
- * In order to capture exceptions, you have to call `setupExpressErrorHandler(app)` before any other middleware and after all controllers.
+ * If you also want to capture errors, you need to call `setupExpressErrorHandler(app)` after you set up your Express server.
+ *
+ * For more information, see the [express documentation](https://docs.sentry.io/platforms/javascript/guides/express/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.expressIntegration()],
+ * })
+ * ```
  */
 export declare const expressIntegration: () => import("@sentry/types").Integration;
 interface MiddlewareError extends Error {
@@ -31,8 +41,28 @@ interface ExpressHandlerOptions {
  */
 export declare function expressErrorHandler(options?: ExpressHandlerOptions): ExpressMiddleware;
 /**
- * Setup an error handler for Express.
+ * Add an Express error handler to capture errors to Sentry.
+ *
  * The error handler must be before any other middleware and after all controllers.
+ *
+ * @param app The Express instances
+ * @param options {ExpressHandlerOptions} Configuration options for the handler
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const express = require("express");
+ *
+ * const app = express();
+ *
+ * // Add your routes, etc.
+ *
+ * // Add this after all routes,
+ * // but before any and other error-handling middlewares are defined
+ * Sentry.setupExpressErrorHandler(app);
+ *
+ * app.listen(3000);
+ * ```
  */
 export declare function setupExpressErrorHandler(app: {
     use: (middleware: ExpressMiddleware) => unknown;

package/build/types-ts3.8/integrations/tracing/fastify.d.ts

@@ -6,13 +6,40 @@ export declare const instrumentFastify: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * Express integration
+ * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).
  *
- * Capture tracing data for fastify.
+ * If you also want to capture errors, you need to call `setupFastifyErrorHandler(app)` after you set up your Fastify server.
+ *
+ * For more information, see the [fastify documentation](https://docs.sentry.io/platforms/javascript/guides/fastify/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.fastifyIntegration()],
+ * })
+ * ```
  */
 export declare const fastifyIntegration: () => import("@sentry/types").Integration;
 /**
- * Setup an error handler for Fastify.
+ * Add an Fastify error handler to capture errors to Sentry.
+ *
+ * @param fastify The Fastify instance to which to add the error handler
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const Fastify = require("fastify");
+ *
+ * const app = Fastify();
+ *
+ * Sentry.setupFastifyErrorHandler(app);
+ *
+ * // Add your routes, etc.
+ *
+ * app.listen({ port: 3000 });
+ * ```
  */
 export declare function setupFastifyErrorHandler(fastify: Fastify): void;
 export {};

package/build/types-ts3.8/integrations/tracing/genericPool.d.ts

@@ -2,9 +2,18 @@ export declare const instrumentGenericPool: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * GenericPool integration
+ * Adds Sentry tracing instrumentation for the [generic-pool](https://www.npmjs.com/package/generic-pool) library.
  *
- * Capture tracing data for GenericPool.
+ * For more information, see the [`genericPoolIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/genericpool/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.genericPoolIntegration()],
+ * });
+ * ```
  */
 export declare const genericPoolIntegration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=genericPool.d.ts.map

package/build/types-ts3.8/integrations/tracing/graphql.d.ts

@@ -28,9 +28,19 @@ export declare const instrumentGraphql: ((options?: GraphqlOptions | undefined)
     id: string;
 };
 /**
- * GraphQL integration
+ * Adds Sentry tracing instrumentation for the [graphql](https://www.npmjs.com/package/graphql) library.
  *
- * Capture tracing data for GraphQL.
+ * For more information, see the [`graphqlIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/graphql/).
+ *
+ * @param {GraphqlOptions} options Configuration options for the GraphQL integration.
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.graphqlIntegration()],
+ * });
  */
 export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/types").Integration;
 export {};

package/build/types-ts3.8/integrations/tracing/hapi/index.d.ts

@@ -3,10 +3,20 @@ export declare const instrumentHapi: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * Hapi integration
+ * Adds Sentry tracing instrumentation for [Hapi](https://hapi.dev/).
  *
- * Capture tracing data for Hapi.
  * If you also want to capture errors, you need to call `setupHapiErrorHandler(server)` after you set up your server.
+ *
+ * For more information, see the [hapi documentation](https://docs.sentry.io/platforms/javascript/guides/hapi/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.hapiIntegration()],
+ * })
+ * ```
  */
 export declare const hapiIntegration: () => import("@sentry/types").Integration;
 export declare const hapiErrorPlugin: {
@@ -16,6 +26,24 @@ export declare const hapiErrorPlugin: {
 };
 /**
  * Add a Hapi plugin to capture errors to Sentry.
+ *
+ * @param server The Hapi server to attach the error handler to
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const Hapi = require('@hapi/hapi');
+ *
+ * const init = async () => {
+ *   const server = Hapi.server();
+ *
+ *   // all your routes here
+ *
+ *   await Sentry.setupHapiErrorHandler(server);
+ *
+ *   await server.start();
+ * };
+ * ```
  */
 export declare function setupHapiErrorHandler(server: Server): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/kafka.d.ts

@@ -2,9 +2,17 @@ export declare const instrumentKafka: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * KafkaJs integration
+ * Adds Sentry tracing instrumentation for the [kafkajs](https://www.npmjs.com/package/kafkajs) library.
  *
- * Capture tracing data for KafkaJs.
+ * For more information, see the [`kafkaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/kafka/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.kafkaIntegration()],
+ * });
  */
 export declare const kafkaIntegration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=kafka.d.ts.map

package/build/types-ts3.8/integrations/tracing/knex.d.ts

@@ -0,0 +1,19 @@
+export declare const instrumentKnex: ((options?: unknown) => void) & {
+    id: string;
+};
+/**
+ * Knex integration
+ *
+ * Capture tracing data for [Knex](https://knexjs.org/).
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.knexIntegration()],
+ * });
+ * ```
+ */
+export declare const knexIntegration: () => import("@sentry/types").Integration;
+//# sourceMappingURL=knex.d.ts.map

package/build/types-ts3.8/integrations/tracing/koa.d.ts

@@ -1,7 +1,45 @@
 export declare const instrumentKoa: ((options?: unknown) => void) & {
     id: string;
 };
+/**
+ * Adds Sentry tracing instrumentation for [Koa](https://koajs.com/).
+ *
+ * If you also want to capture errors, you need to call `setupKoaErrorHandler(app)` after you set up your Koa server.
+ *
+ * For more information, see the [koa documentation](https://docs.sentry.io/platforms/javascript/guides/koa/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.koaIntegration()],
+ * })
+ * ```
+ */
 export declare const koaIntegration: () => import("@sentry/types").Integration;
+/**
+ * Add an Koa error handler to capture errors to Sentry.
+ *
+ * The error handler must be before any other middleware and after all controllers.
+ *
+ * @param app The Express instances
+ * @param options {ExpressHandlerOptions} Configuration options for the handler
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const Koa = require("koa");
+ *
+ * const app = new Koa();
+ *
+ * Sentry.setupKoaErrorHandler(app);
+ *
+ * // Add your routes, etc.
+ *
+ * app.listen(3000);
+ * ```
+ */
 export declare const setupKoaErrorHandler: (app: {
     use: (arg0: (ctx: any, next: any) => Promise<void>) => void;
 }) => void;

package/build/types-ts3.8/integrations/tracing/lrumemoizer.d.ts

@@ -2,9 +2,17 @@ export declare const instrumentLruMemoizer: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * LruMemoizer integration
+ * Adds Sentry tracing instrumentation for the [lru-memoizer](https://www.npmjs.com/package/lru-memoizer) library.
  *
- * Propagate traces through LruMemoizer.
+ * For more information, see the [`lruMemoizerIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/lrumemoizer/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.lruMemoizerIntegration()],
+ * });
  */
 export declare const lruMemoizerIntegration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=lrumemoizer.d.ts.map

package/build/types-ts3.8/integrations/tracing/mongo.d.ts

@@ -2,9 +2,18 @@ export declare const instrumentMongo: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * MongoDB integration
+ * Adds Sentry tracing instrumentation for the [mongodb](https://www.npmjs.com/package/mongodb) library.
  *
- * Capture tracing data for MongoDB.
+ * For more information, see the [`mongoIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mongo/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mongoIntegration()],
+ * });
+ * ```
  */
 export declare const mongoIntegration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=mongo.d.ts.map

package/build/types-ts3.8/integrations/tracing/mongoose.d.ts

@@ -2,9 +2,18 @@ export declare const instrumentMongoose: ((options?: unknown) => void) & {
     id: string;
 };
 /**
- * Mongoose integration
+ * Adds Sentry tracing instrumentation for the [mongoose](https://www.npmjs.com/package/mongoose) library.
  *
- * Capture tracing data for Mongoose.
+ * For more information, see the [`mongooseIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mongoose/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mongooseIntegration()],
+ * });
+ * ```
  */
 export declare const mongooseIntegration: () => import("@sentry/types").Integration;
 //# sourceMappingURL=mongoose.d.ts.map