How do you use @sentry/cloudflare with Custom Managed Components?

[wuservices]

I'm excited that Sentry now has an official Cloudflare Workers integration from #13007. I see there is support for various parts of the Cloudflare ecosystem, but didn't see any suggestions for using with a Custom Managed Component - used with Cloudflare Zaraz.

The tricky part here is that you essentially build a specialized worker via managed-component-to-cloudflare-worker. Your code exports a special handler, rather than the fetch that withSentry would typically instrument. Since you don't have access to fetch, it seems like you can't follow the typical integration pattern.

I'm looking for any suggestions or guidance, but so far have a Claude Code assisted solution and summary below that seems to sort of work.

Context

I'm using a Cloudflare Managed Component (via Zaraz/Tag Management). Managed Components don't follow the standard Cloudflare Worker export pattern:

// Standard Worker pattern (what withSentry expects)                                                                                                                                                                                                                                    
export default {                                                                                                                                                                                                                                                                        
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> { }                                                                                                                                                                                                 
}                                                                                                                                                                                                                                                                                       
                                                                                                                                                                                                                                                                                        
// Managed Component pattern (what I have)                                                                                                                                                                                                                                              
export default async function (manager: Manager, settings: ComponentSettings) {                                                                                                                                                                                                         
  manager.addEventListener('pageview', handleEvent)                                                                                                                                                                                                                                     
}                                                               

The https://github.com/cloudflare/managed-component-to-cloudflare-worker bundler wraps my component in a standard Worker, but I don't have access to modify that wrapper.

Problem

The @sentry/cloudflare SDK's withSentry() wrapper expects the standard Worker API with Request, Env, and ExecutionContext. Since:

1. My component doesn't export a fetch handler
2. The init() function exists in the SDK but isn't exported from the main package index
3. I can't modify the generated Worker wrapper

I needed an alternative initialization approach.

Working Solution

I used @sentry/core directly with ServerRuntimeClient instead of CloudflareClient:

// src/sentry.ts                                                                                                                                                                                                                                               
import {                                                                                                                                                                                                                                                                                
  captureException,                                                                                                                                                                                                                                                                     
  createTransport,                                                                                                                                                                                                                                                                      
  functionToStringIntegration,                                                                                                                                                                                                                                                          
  getIntegrationsToSetup,                                                                                                                                                                                                                                                               
  inboundFiltersIntegration,                                                                                                                                                                                                                                                            
  initAndBind,                                                                                                                                                                                                                                                                          
  linkedErrorsIntegration,                                                                                                                                                                                                                                                              
  ServerRuntimeClient,                                                                                                                                                                                                                                                                  
  setTag                                                                                                                                                                                                                                                                                
} from '@sentry/core'                                                                                                                                                                                                                                                                   
import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/cloudflare'                                                                                                                                                                                                           
                                                                                                                                                                                                                                                                                        
function makeTransport(options) {                                                                                                                                                                                                                                                       
  function makeRequest(request) {                                                                                                                                                                                                                                                       
    return fetch(options.url, {                                                                                                                                                                                                                                                         
      body: request.body,                                                                                                                                                                                                                                                               
      method: 'POST',                                                                                                                                                                                                                                                                   
      headers: options.headers                                                                                                                                                                                                                                                          
    }).then(async response => {                                                                                                                                                                                                                                                         
      await response.text() // Consume body per CF requirements                                                                                                                                                                                                                         
      return {                                                                                                                                                                                                                                                                          
        statusCode: response.status,                                                                                                                                                                                                                                                    
        headers: {                                                                                                                                                                                                                                                                      
          'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),                                                                                                                                                                                                         
          'retry-after': response.headers.get('Retry-After')                                                                                                                                                                                                                            
        }                                                                                                                                                                                                                                                                               
      }                                                                                                                                                                                                                                                                                 
    })                                                                                                                                                                                                                                                                                  
  }                                                                                                                                                                                                                                                                                     
  return createTransport(options, makeRequest)                                                                                                                                                                                                                                          
}                                                                                                                                                                                                                                                                                       
                                                                                                                                                                                                                                                                                        
export function initSentry() {                                                                                                                                                                                                                                                          
  setAsyncLocalStorageAsyncContextStrategy()                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                        
  const integrations = [                                                                                                                                                                                                                                                                
    inboundFiltersIntegration(),                                                                                                                                                                                                                                                        
    functionToStringIntegration(),                                                                                                                                                                                                                                                      
    linkedErrorsIntegration()                                                                                                                                                                                                                                                           
  ]                                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                        
  initAndBind(ServerRuntimeClient, {                                                                                                                                                                                                                                                    
    dsn: 'https://[email protected]/xxx',                                                                                                                                                                                                                                     
    tracesSampleRate: 1.0,                                                                                                                                                                                                                                                              
    transport: makeTransport,                                                                                                                                                                                                                                                           
    stackParser: simpleStackParser, // Custom parser                                                                                                                                                                                                                                    
    platform: 'cloudflare',                                                                                                                                                                                                                                                             
    runtime: { name: 'cloudflare-worker' },                                                                                                                                                                                                                                             
    integrations: getIntegrationsToSetup({ defaultIntegrations: integrations }),                                                                                                                                                                                                        
    _metadata: {                                                                                                                                                                                                                                                                        
      sdk: {                                                                                                                                                                                                                                                                            
        name: 'sentry.javascript.cloudflare',                                                                                                                                                                                                                                           
        version: '10.35.0',                                                                                                                                                                                                                                                             
        packages: [{ name: 'npm:@sentry/cloudflare', version: '10.35.0' }]                                                                                                                                                                                                              
      }                                                                                                                                                                                                                                                                                 
    }                                                                                                                                                                                                                                                                                   
  })                                                                                                                                                                                                                                                                                    
}                                            

Important: initSentry() must be called after remapping fetch to manager.fetch in Managed Components.

Questions for Sentry Team

1. Would it make sense to export init() from the main package index? This would support Managed Components, Durable Objects, and other non-standard patterns.
2. Is using ServerRuntimeClient directly a supported/recommended approach? Or is there a better way?
3. Any concerns with this workaround? It's working but feels like fighting the SDK design.