Overwriting by using withScope does not work:

toucan.withScope(scope => {
   scope.setTag('ip', 'foo') // this works
   scope.setUser({ ip: 'foo' }) // this does not work
   scope.setTag('environment', 'dev') // this does not work

  // ...
  // captureEvent()
})

It looks like environment and user ip or ip_address cannot be overwritten. Is there a way to do that?

Great package! 👏

Unless there's a purpose "EdgeWorker" serves, would be nice if this were a configurable value. Especially since it appears in the Sentry Issues list.

Given maintainer approval on an option name, maybe even logger: string;, I'd be happy to contribute this change.

Right now, if I have a ToucanJS instance & I want to disable it, I have to add guard checks around it (or make it an | undefined type & invoke it through ? safely). It would be convenient if the ToucanJS instance could be told to disable so that we would still have an instance against which we perform actions but the actual outbound fetches get disabled (& could be reenabled for completeness if needed). This was a confounding factor to some incidents.

@sentry/integrations v7.36.0
toucan-js: v3.3.0

This:

import { RewriteFrames } from '@sentry/integrations'
import { Toucan } from 'toucan-js'

interface Env {}

export default {
  async fetch(req: Request, env: Env, ctx: ExecutionContext) {
    new Toucan({
      dsn: '',
      context: ctx,
      request: req,
      release: 'some release',
      integrations: [new RewriteFrames({ root: '/' })],
    })
  }
}

fails with

error TS2322: Type 'RewriteFrames' is not assignable to type 'Integration'.
  Types of property 'setupOnce' are incompatible.
    Type '(addGlobalEventProcessor: (callback: import("node_modules/@sentry/integrations/node_modules/@sentry/types/types/eventprocessor").EventProcessor) => void, getCurrentHub: () => import("node_modules/@sentry/integrations/node_modules/@sentry/typ...' is not assignable to type '(addGlobalEventProcessor: (callback: import("node_modules/@sentry/types/types/eventprocessor").EventProcessor) => void, getCurrentHub: () => import("node_modules/@sentry/types/types/hub").Hub) => void'.
      Types of parameters 'addGlobalEventProcessor' and 'addGlobalEventProcessor' are incompatible.
        Types of parameters 'callback' and 'callback' are incompatible.
          Type 'import("node_modules/@sentry/integrations/node_modules/@sentry/types/types/eventprocessor").EventProcessor' is not assignable to type 'import("node_modules/@sentry/types/types/eventprocessor").EventProcessor'.
            Types of parameters 'hint' and 'hint' are incompatible.
              Type 'import("node_modules/@sentry/types/types/event").EventHint' is not assignable to type 'import("node_modules/@sentry/integrations/node_modules/@sentry/types/types/event").EventHint'.
                Types of property 'captureContext' are incompatible.
                  Type 'import("node_modules/@sentry/types/types/scope").CaptureContext | undefined' is not assignable to type 'node_modules/@sentry/integrations/node_modules/@sentry/types/types/scope").CaptureContext | undefined'.
                    Type 'Scope' is not assignable to type 'CaptureContext | undefined'.

26     integrations: [new RewriteFrames({ root: '/' })],
                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

It seems that Sentry has deprecated the release-based sourcemap uploading system used by toucan-js, and instead switched to a new system called "artifact bundles".

Unfortunately, it seems that toucan doesn't support this system yet.

At minimum (but I believe there is more to do as well), it looks like we need to use sentry version 7.47.0 — this library is currently using 7.43.0.

Is this something you plan to support?

either via SENTRY_ENVIRONMENT env var or from the constructor?

Hello again.

So I've using Toucan for a while in a couple of Cloudflare Workers projects now and have been wondering if we could change it so that I could instantiate the instance only once in the global context and reuse it for every request, like this:

type Handler = (req: Request) => Response | Promise<Response>;

declare const SENTRY_DSN: string;

const sentry = new Toucan({ dsn: SENTRY_DSN });

async function catchErrors(event: FetchEvent, handler: Handler): Promise<Response> {
  try {
    return await handler(event.request);
  } catch (err) {
    sentry.captureException(err, event);

    return new Response(null, { status: 500 });
  }
}

Of course, this would be a breaking change, so another idea I had was to make an extends method:

type Handler = (req: Request) => Response | Promise<Response>;

declare const SENTRY_DSN: string;

const baseSentry = new Toucan({ dsn: SENTRY_DSN });

async function catchErrors(event: FetchEvent, handler: Handler): Promise<Response> {
  const sentry = baseSentry.extend({ event });

  try {
    return await handler(event.request);
  } catch (err) {
    sentry.captureException(err, event);

    return new Response(null, { status: 500 });
  }
}

These ways we could define defaults and avoid instantiating extra objects at every request, but since Toucan's constructor requires the FetchEvent, neither of these options are possible right now.

I'm trying to read the documentation in order to attach the body of the request when an error happens.
This seems to be possible with setRequestBody, but the docs are clear at all about how to use said option.

Is that a boolean value? Is it a function? Should I call it (and how?)

Using from the RewriteFrames the latest @sentry/integrations no longer works. The integration's processEvent is never called.

I believe this is because of a recent refactoring from Sentry where the integration's setupOnce become a noop (source)

Toucan depends on setupOnce calling the function that is passed to it, otherwise the event processor is never added to the SDK's scope (source).

Sentry SDK has undergone some important changes over the past few months since version 6.19.6.

The breaking changes we introduced in v7 are minimal and easy to migrate. You can check the migration docs here.

By the way, I am from the Sentry SDK team and in case you need help migrating let me know.

Thanks for building this library!

#67 added support for modules, but it looks like it still depends on FetchEvent.waitUntil:

Since modules only receive a request object, and no fetch event, this causes an exception (can replicate with debug mode):

toucan-js: TypeError: Cannot read property 'waitUntil' of undefined

You can cheat a bit and provide a dummy function in context, but this won't do anything to tell the runtime to extend the lifetime of the promise, and you end up waiting for exception handling to complete before generating a response:

    const sentry = new Toucan({
      dsn: <DSN>,
      request,
      context: {
        waitUntil: async (cb) => await cb(),
      }
    });

Maybe I'm missing something here? Happy to contribute if there's something actionable here but I haven't found it.

When trying to build the basic example, I get the following error:

∴ yarn build
yarn run v1.22.19
$ wrangler publish --dry-run --outdir=dist
 ⛅️ wrangler 2.5.0 (update available 2.6.2)
-----------------------------------------------------

✘ [ERROR] Could not resolve "toucan-js"

    src/index.ts:1:23:
      1 │ import { Toucan } from 'toucan-js';
        ╵                        ~~~~~~~~~~~

  You can mark the path "toucan-js" as external to exclude it from the bundle, which will remove this error.


✘ [ERROR] Build failed with 1 error:

  src/index.ts:1:23: ERROR: Could not resolve "toucan-js"


error Command failed with exit code 1.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.

I had assumed the build task would be configured to handle bundling. Is this not the case?

It looks like Toucan uses /// <reference types="@cloudflare/workers-types" /> to reference the ambient types for Cloudflare Workers. Unfortunately, that means that those types are included in any code that imports toucan-js, which isn't always the right behaviour. Specifically, I ran into an incompatibility between the latest compatibility date version of the types (@cloudflare/workers-types/experimental), and the oldest (which is what Toucan includes by default).

I think the fix will be to import the needed types from @cloudflare/workers-types when used in toucan-js.

Here is the diff that solved my problem:

diff --git a/node_modules/toucan-js/dist/transports/types.d.ts b/node_modules/toucan-js/dist/transports/types.d.ts
index 1503db4..3669365 100644
--- a/node_modules/toucan-js/dist/transports/types.d.ts
+++ b/node_modules/toucan-js/dist/transports/types.d.ts
@@ -1,4 +1,3 @@
-/// <reference types="@cloudflare/workers-types" />
 import type { BaseTransportOptions } from '@sentry/types';
 import type { Context } from '../types';
 export type FetchTransportOptions = BaseTransportOptions & {
diff --git a/node_modules/toucan-js/dist/types.d.ts b/node_modules/toucan-js/dist/types.d.ts
index d7bd18b..061aa19 100644
--- a/node_modules/toucan-js/dist/types.d.ts
+++ b/node_modules/toucan-js/dist/types.d.ts
@@ -1,4 +1,3 @@
-/// <reference types="@cloudflare/workers-types" />
 import type { ClientOptions, Options as CoreOptions } from '@sentry/types';
 import type { RequestDataOptions } from './integrations';
 import type { FetchTransportOptions } from './transports';

I'm seeing this in my logs. Any thoughts?

Your worker called response.clone(), but did not read the body of both clones. This is wasteful, as it forces the system to buffer the entire response body in memory, rather than streaming it through. This may cause your worker to be unexpectedly terminated for going over the memory limit. If you only meant to copy the response headers and metadata (e.g. in order to be able to modify them), use `new Response(response.body, response)` instead.

Hi,

I am unable to import the type Options use in constructor of class Toucan.
Is there a way of importing it?

Thanks for making this lib !

Now last version is 7.40.0. I can't use because got conflicts with typings. And, for example, i can not use library version of sentry typings, because toucan doe not reexport them

Followed the guide in the README and the thread but I'm still getting errors when attempting to link to my source map.

Maybe I'm missing or misunderstanding something still?

addEventListener('fetch', (event) => {
  const sentry = new Toucan({
    dsn: SENTRY_DSN,
    event,
    environment: 'development',
    release: 'pre-release',
    allowedCookies: /(.*)/,
    allowedHeaders: /(.*)/,
    allowedSearchParams: /(.*)/,
    rewriteFrames: {
      root: '/'
    }
  })

  event.respondWith(handleRequest(event, sentry))
})

const SentryWebpackPlugin = require('@sentry/webpack-plugin')

module.exports = {
  entry: './src/index.js',
  target: 'webworker',
  devtool: 'cheap-module-source-map',
  node: {
    fs: 'empty'
  },
  plugins: [
    new SentryWebpackPlugin({
      authToken: 'abc123',
      release: 'pre-release',
      org: 'abc',
      project: '123',
      include: './dist',
      urlPrefix: '/',
    }),
  ],
}

Hi I'm using one of the example provided in toucan-js/example specifically wrangler-basic. I was expecting to see the error with source map in sentry dash but I only get a stack trace. I can confirm the files have been uploaded but it seems they are not linked.
has anything changed since the creation of the example to make it work.
I ran build and then deploy i got no error or warning in the terminal.

1. pass request with /test?snake_case=foo&camelCase=bar
2. value for key camelCase becomes undefined

Hi y'all, I'm having trouble getting source maps to work.

I'm testing by throwing an error in the _index.tsx route, but the source map is wrong.

Here's a minimal reproduction
https://github.com/vladinator1000/remix-cloudflare-pages-sentry

Is this a bug, or does anyone see where I'm going wrong here?

From the README, passing a function to context.waitUntil don't seem to work.

export default {
    async scheduled(controller: Controller, env: Env, context: Context) {
        //...
        context.waitUntil(async () => {
            try {
                // Your code
            } catch (err) {
                sentry.captureException(err);
            }
        });
    },
}

From Cloudflare Documentation / ScheduledEvent / Syntax: Module Worker, the function passed to context.waitUntil must be called

export default {
    async scheduled(event, env, ctx) {
        ctx.waitUntil(doSomeTaskOnASchedule());
    },
};

so the code that works:

export default {
    async scheduled(controller: Controller, env: Env, context: Context) {
        //...
        context.waitUntil((async () => {
            try {
                // Your code
            } catch (err) {
                sentry.captureException(err);
            }
        })());
    },
}

• module (.mjs)
• wrangler 2.1.6
• node: v18.9.0
• OS: ArchLinux

Thanks for the lib, looks great. Wondering if you have any advice on source maps or legible stack traces in the Sentry Dashboar?

Hi,

why is startTransaction() returning null in this case? (sentry object works and is used in my app):

      const sentry = new Toucan({
         dsn: env.SENTRY_DSN,
         context,
         request,
      });

      const transaction = sentry.startTransaction({
         name: "Some Name",
      });

Do i need to import something besides the main Toucan package?

Thanks.

Sentry has released a few features, namely performance monitoring and metrics (beta), that would be a great addition in the Cloudflare Workers environment.

Do you have any plans to bring these features to Toucan or merge automatic PRs for newer Sentry package versions?

Calling configureScope seems to do absolutely nothing. Putting a log inside the callback results in nothing being logged.

Looking at the source, I don't see configureScope implemented at all, but I do see that the whole class is wrapped in a Proxy, which I suspect is suppressing errors you'd normally get for calling an undefined method.

Has anyone got Toucan to work with SvelteKit on Cloudflare Pages?

EDIT

For now I just hooked Toucan up in src/hooks.server.ts

import type { HandleServerError } from '@sveltejs/kit';
import { Toucan } from 'toucan-js';

// use handleError to report errors during server-side data loading
export const handleError: HandleServerError = ({ error, event }) => {
	const sentry = new Toucan({
		dsn: '<DSN>',
		request: event.request
	});

	sentry.captureException(error);

	return {
		message: error instanceof Error && 'message' in error ? error.message : String(error)
	};
};

https://docs.sentry.io/platforms/node/crons/

Sentry will support cron monitoring. It is good to use with the cf scheduled trigger. I hope toucan-js will integrate with it.

Hi,
I'm trying to write middleware that uses Sentry for distributed tracing through Toucan for an Astro site with Cloudflare Workers SSR.

As is, the only reporting I'm seeing is individual event propagation via e.g. captureException. With the code as-is, these errors are unconnected to any individual trace even though the Sentry-Trace header is being sent to the server side (and is on the same domain so doesn't have any CORS problems).

I'm able to use the relatively new propagationContextFromHeaders utility function like so:

import { propagationContextFromHeaders } from "@sentry/utils";
export const onRequest = defineMiddleware(async (context, next) => {
// ...
  const propagationContext = propagationContextFromHeaders(
    context.request.headers.get("sentry-trace") ?? undefined,
    context.request.headers.get("baggage")
  );
  // @ts-expect-error because of minor mismatch in propagationContext type
  sentry.getScope().setPropagationContext(propagationContext);

And then errors will end up logged and associated with the trace id initiated on the client side, but with no information beyond the fact the error happened. However, even when I add the Transaction integration via integrations: [new Transaction()], in the Toucan constructor, I don't see any sentry reporting about the spans and or transaction that the individual trace was a part of.

I understand that performance timing / Date.now() are inaccurate on the CF Worker platform, but I am wondering whether there is a way to get Toucan to still report the (inaccurate) timestamps and transactions/spans. I tried creating new transactions/child spans, running .finish(), and still don't see anything reported, either using a beforeSend hook in the Toucan constructor or on the Sentry dashboard.

Is there a way to get those reported? And would a PR adding the propagation context by default in Toucan be desirable? Thanks!

Hey there, great work on the Sentry client, I love it 🙇

I have more of a question because I can't find anywhere else to ask. I switched to module syntax for Workers and I have trouble uploading source maps. I use Webpack with experiments.outputModule to generate the code. Here's my webpack.config.js:

if (process.env.SENTRY_AUTH_TOKEN) {
  plugins.push(
    new SentryWebpackPlugin({
      authToken: process.env.SENTRY_AUTH_TOKEN,
      org: 'random-org',
      project: 'random-project',
      release: process.env.RELEASE,
      include: './dist',
      urlPrefix: '/',
      ignore: ['node_modules']
    })
  )
}

module.exports = {
  output: {
    filename: `worker.mjs`,
    libraryTarget: 'module',
    path: path.join(__dirname, 'dist')
  },
  mode,
  resolve: {
    extensions: ['.ts', '.js']
  },
  devtool: 'source-map',
  module: {
    rules: [
      {
        test: /\.tsx?$/,
        loader: 'ts-loader',
      }
    ]
  },
  experiments: {
    outputModule: true
  },
  plugins
}

I get the worker.mjs.map but when it is uploaded to Sentry it doesn't 'connect' properly to the stack trace I receive. Did anyone get source maps working with the modules syntax and Sentry so far?

Thanks for all the work here 🙇

Hi! I want to use toucan-js for collecting tracing data with my cloudflare workers application.

I have set up the tracesSampleRate when new Toucan({<options>}), but it does not work, no data on the sentry performance panel appeared.

What should I do to use toucan with tracing correctly?

Thank in advance!

When running yarn inside the basic example, the following error occurs:

error An unexpected error occurred: "https://registry.yarnpkg.com/config-typescript: Not found".

Apparently stacktrace-js already includes type definitions as of version 2.0.0.

warning toucan-js > @types/[email protected]: This is a stub types definition. stacktrace-js provides its own type definitions, so you do not need this installed.

In Toucan options there are now two places for DSN:

• dsn (has star in README, optional in code)
• transportOptions.dsn (described as string in README, a DsnLike from @sentry/types in code)

Both can only be set at initialization. What is the difference between these options? Looking at the code, it seems like transportOptions.dsn is used to rewrite options.dsn, the purpose behind this is unclear and not documented.

Any plans to add support for cron triggers that use ScheduledEvent instead of FetchEvent?

Just wanted to give a heads up that Durable Objects and standard Workers written as modules is on my radar, but there are still many moving pieces in BETA and so I don't want to rush this. I'm expecting breaking changes in how toucan-js is going to consume event properties like waitUntil or request in mjs world.

Hi! Thanks for Toucan 🙏

I've found that setExtras shallow merges objects - and on investigation, confirmed that this is also the case in @sentry/core: https://github.com/getsentry/sentry-javascript/blob/master/packages/hub/src/hub.ts#L313

I tested this in a fork, and proposed a changed to the Toucan docs, but this issue may be enough - merging the PR might be unnecessary - whatever!

Test and suggested readme change: ptim/toucan-js/pull/1

The following repro will send timestamps with year 2077 in Self Hosted:
In Sentry.io the transaction is dropped (I assume because it is 53 years in the future!)

import { Toucan } from "toucan-js";
import { addTracingExtensions } from '@sentry/core';

export interface Env {
  SENTRY_DSN: string;
}

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    addTracingExtensions();
    const sentry = new Toucan({
      dsn: env.SENTRY_DSN,
      release: '1.0.0',
      context: ctx,
      request,
      sampleRate: 1.0,
      tracesSampleRate: 1.0,
      enableTracing: true,
    });

    const transaction = sentry.startTransaction({ name: 'test', description: 'test', op: 'http.server', metadata: { source: 'route' } });
    try {
      await fetch('https://google.com'); // just to cause some IO
      return new Response('Hello world!');
    } catch (e) {
      sentry.captureException(e);

      return new Response('Something went wrong! Team has been notified.', {
        status: 500,
      });
    } finally {
      transaction.finish();
    }
  },
};

Passing startTimestamp and endTimestamp explicitly via performance.now()/1000 it works as expected.
I have raised this issue with sentry, but they asked me to follow up here.
I am sorry if this is not related to this repo, but it could be worth being aware.

According to these docs the Hub object that Toucan's main class extends has been deprecated since Sentry v7.110.0

https://docs.sentry.io/platforms/javascript/migration/v7-to-v8/v7-deprecations/#deprecate-hub

I'm using Hono with @hono/sentry that integrates Toucan and the following both yield deprecation warnings

c.get('sentry').setContext({ ... })
c.get('sentry').captureException(err)

How can we access the new Sentry object? Should Toucan be extending the new Sentry object? Should we use @sentry/node?

The official Sentry documentation states:

sampleRate
Configures the sample rate as a percentage of events to be sent in the range of 0.0 to 1.0. The default is 1.0 which means that 100% of events are sent. If set to 0.1 only 10% of events will be sent. Events are picked randomly.

It would be very valuable to make this a configurable option in toucan-js.

sentry.getScope().setTransactionName('whatever'); results TypeError: sentry.getScope(...).setTransactionName is not a function.

Hi,
I was using setFingerprint function to create a customer identifier for errors, but it seems like v3 removed this option (and it's not mentioned in the changelog?)

Is there an alternative usage for setting the fingerprint of an exception reported?

Thanks!

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

Open

These updates have all been created already. Click a checkbox below to force a retry/rebase of any.

• chore(deps): update all non-major dependencies (@changesets/cli, @cloudflare/workers-types, @rollup/plugin-node-resolve, @rollup/plugin-replace, @types/jest, @typescript-eslint/eslint-plugin, @typescript-eslint/parser, eslint, eslint-config-turbo, jest, jest-environment-miniflare, miniflare, prettier, rollup, rollup-plugin-typescript2, ts-jest, ts-node, turbo, typescript)
• fix(deps): update sentry dependencies to v8.26.0 (@sentry/core, @sentry/types, @sentry/utils)
• chore(deps): update dependency rollup to v4
• chore(deps): update dependency turbo to v2
• fix(deps): update dependency eslint to v9
• fix(deps): update dependency eslint-config-turbo to v2
• fix(deps): update typescript-eslint monorepo to v8 (major) (@typescript-eslint/eslint-plugin, @typescript-eslint/parser)
• Click on this checkbox to rebase all open PRs at once

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

I'd like to use my own transport fetch-like mechansim instead of global fetch. Would a PR making a change here be acceptable so that the fetch function can be injected as a transport option?

We're re-throwing an error to add context and setting the cause optional property to preserve the original error
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause

It'd be great to see the cause show up in Sentry as a part of the error info. It looks like sending the error.cause as an additional exception in the list might be the way to go https://develop.sentry.dev/sdk/event-payloads/exception/#examples

"toucan-js": "3.1.0"

const transaction = sentry.startTransaction({ name: 'Incoming request' })
// undefined

It looks like Toucan is not sending sessions/session data to Sentry. I see no session being recorded after I ran the worker several times:

Here's the worker TypeScript code:

import { Toucan } from 'toucan-js';

export interface Env {}

export default {
	async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
		const sentry = new Toucan({
			dsn: 'ADD_YOUR_DSN_HERE',
			context: ctx,
			request,
			release: 'fetch',
		});

		try {
			// throw new Error('This is a test error');
			return new Response('Hello World!');
		} catch (error) {
			sentry.captureException(error);
			return new Response('Internal Server Error', { status: 500 });
		}
	},
};

Is this a bug?
Or, perhaps, a feature missing from Toucan?
Or, perhaps, I am missing something?

Thanks in advance 👍

Hi! I appreciate the work you've put into building this library and I'm actively using it on Cloudflare Workers.

I was wondering if there are any instructions on how to set it up with next-on-pages as well?

Hey there,

thanks for the great library! I've trying to use sentry performance tracking https://docs.sentry.io/platforms/node/performance/ on cf workers for quite some time, but couldn't get it working cause of the timer blocking.
I've read of the partnering with sentry through this library on the cf blog and wanted to ask if it's intended to get the performance monitoring somehow working?

Thanks

Alex

I do have nodejs compatibility set for my workers in wrangler.toml and i'm inclined to choose Sentry nodejs project. but im worried that might be a mistake and hoping for some advice please :)