Merge branch 'develop' into sig/consola-obj-keys

Author: s1gr1d

.cursor/commands/add_cdn_bundle.md

@@ -0,0 +1,63 @@
+import { ChatAnthropic } from '@langchain/anthropic';
+import { RunnableLambda, RunnableSequence } from '@langchain/core/runnables';
+import { createLangChainCallbackHandler } from '@sentry/core';
+import * as Sentry from '@sentry/node';
+import express from 'express';
+
+function startMockAnthropicServer() {
+  const app = express();
+  app.use(express.json());
+
+  app.post('/v1/messages', (req, res) => {
+    res.json({
+      id: 'msg_chain_test',
+      type: 'message',
+      role: 'assistant',
+      content: [{ type: 'text', text: 'The weather is sunny.' }],
+      model: req.body.model,
+      stop_reason: 'end_turn',
+      stop_sequence: null,
+      usage: { input_tokens: 10, output_tokens: 5 },
+    });
+  });
+
+  return new Promise(resolve => {
+    const server = app.listen(0, () => {
+      resolve(server);
+    });
+  });
+}
+
+async function run() {
+  const server = await startMockAnthropicServer();
+  const baseUrl = `http://localhost:${server.address().port}`;
+
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    const model = new ChatAnthropic({
+      model: 'claude-3-5-sonnet-20241022',
+      temperature: 0,
+      maxTokens: 50,
+      apiKey: 'mock-api-key',
+      clientOptions: { baseURL: baseUrl },
+    });
+
+    const formatStep = RunnableLambda.from(input => `Tell me about: ${input.topic}`).withConfig({
+      runName: 'format_prompt',
+    });
+
+    const parseStep = RunnableLambda.from(output => output.content[0].text).withConfig({
+      runName: 'parse_output',
+    });
+
+    const chain = RunnableSequence.from([formatStep, model, parseStep]);
+
+    const handler = createLangChainCallbackHandler();
+
+    await chain.invoke({ topic: 'weather' }, { callbacks: [handler] });
+  });
+
+  await Sentry.flush(2000);
+  server.close();
+}
+
+run();

.cursor/commands/bump_otel_instrumentations.md

@@ -376,4 +376,41 @@ describe('LangChain integration', () => {
       });
     },
   );
+
+  createEsmAndCjsTests(__dirname, 'scenario-chain.mjs', 'instrument.mjs', (createRunner, test) => {
+    test('uses runName for chain spans instead of unknown_chain', async () => {
+      await createRunner()
+        .ignore('event')
+        .expect({
+          transaction: {
+            transaction: 'main',
+            spans: expect.arrayContaining([
+              expect.objectContaining({
+                description: 'chain format_prompt',
+                op: 'gen_ai.invoke_agent',
+                origin: 'auto.ai.langchain',
+                data: expect.objectContaining({
+                  'langchain.chain.name': 'format_prompt',
+                }),
+              }),
+              expect.objectContaining({
+                description: 'chain parse_output',
+                op: 'gen_ai.invoke_agent',
+                origin: 'auto.ai.langchain',
+                data: expect.objectContaining({
+                  'langchain.chain.name': 'parse_output',
+                }),
+              }),
+              expect.objectContaining({
+                description: 'chat claude-3-5-sonnet-20241022',
+                op: 'gen_ai.chat',
+                origin: 'auto.ai.langchain',
+              }),
+            ]),
+          },
+        })
+        .start()
+        .completed();
+    });
+  });
 });

.cursor/commands/publish_release.md

@@ -0,0 +1,12 @@
+# Browser SDK
+
+## Bundle Size
+
+Bundle size is critical. Be mindful of imports and tree-shaking.
+
+- [Bundle size documentation](https://develop.sentry.dev/sdk/platform-specifics/javascript-sdks/bundle-size.md)
+- [Browser tracing documentation](https://develop.sentry.dev/sdk/platform-specifics/javascript-sdks/browser-tracing.md)
+
+## CDN Bundles
+
+Use `/add-cdn-bundle` skill to create new CDN bundles.

.cursor/rules/fetch-docs/bundle-size.mdc

@@ -184,8 +184,17 @@ export function createLangChainCallbackHandler(options: LangChainOptions = {}):
     },
 
     // Chain Start Handler
-    handleChainStart(chain: { name?: string }, inputs: Record<string, unknown>, runId: string, _parentRunId?: string) {
-      const chainName = chain.name || 'unknown_chain';
+    handleChainStart(
+      chain: { name?: string },
+      inputs: Record<string, unknown>,
+      runId: string,
+      _parentRunId?: string,
+      _tags?: string[],
+      _metadata?: Record<string, unknown>,
+      _runType?: string,
+      runName?: string,
+    ) {
+      const chainName = runName || chain.name || 'unknown_chain';
       const attributes: Record<string, SpanAttributeValue> = {
         [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ai.langchain',
         'langchain.chain.name': chainName,

.cursor/rules/fetch-docs/tracing-in-browser.mdc

@@ -0,0 +1,77 @@
+# Next.js SDK (`@sentry/nextjs`)
+
+## Bundler Architecture: Webpack vs Turbopack
+
+Next.js apps use **either webpack or turbopack** as their bundler. This fundamentally changes how Sentry instruments the application.
+
+- **Webpack** — default bundler through Next.js 15
+- **Turbopack** — default bundler starting Next.js 16
+
+Detection: `process.env.TURBOPACK` or `--turbo` CLI flag (see `src/config/util.ts:detectActiveBundler`).
+
+### Webpack Path (Build-Time Wrapping)
+
+Webpack builds use **loaders and templates** to wrap user code at compile time:
+
+1. **Wrapping loader** (`src/config/loaders/wrappingLoader.ts`) identifies route handlers, API routes, pages, middleware, and server components by file path patterns
+2. **Templates** (`src/config/templates/`) inject Sentry instrumentation around each export — using Rollup internally to expand `export *` statements
+3. **Value injection loader** injects globals (`_sentryNextJsVersion`, route manifest, tunnel path, etc.)
+4. **SentryWebpackPlugin** handles sourcemap upload and release management
+
+Template files and what they wrap:
+
+- `pageWrapperTemplate.ts` — Pages Router pages (`getInitialProps`, `getStaticProps`, `getServerSideProps`)
+- `apiWrapperTemplate.ts` — Pages Router API routes
+- `routeHandlerWrapperTemplate.ts` — App Router route handlers (GET, POST, etc.)
+- `serverComponentWrapperTemplate.ts` — App Router server components, `generateMetadata`, `generateViewport`
+- `middlewareWrapperTemplate.ts` — Edge middleware
+
+Config options that control wrapping: `autoInstrumentServerFunctions`, `autoInstrumentMiddleware`, `autoInstrumentAppDirectory`, `excludeServerRoutes`.
+
+### Turbopack Path (No Build-Time Wrapping)
+
+Turbopack does **NOT** use the wrapping loader or templates. There is no build-time function wrapping.
+
+What turbopack **does** support:
+
+- **Value injection** via Turbopack rules (`src/config/turbopack/`) — injects the same globals as webpack
+- **Module metadata injection** (`moduleMetadataInjectionLoader.ts`) — enables `thirdPartyErrorFilterIntegration` (requires Next.js 16+ and `_experimental.turbopackApplicationKey`)
+- **Native debug IDs** for sourcemaps (Next.js 15.6+)
+- **`runAfterProductionCompile` hook** (enabled by default) for sourcemap upload
+
+What turbopack does **NOT** support:
+
+- Build-time wrapping of route handlers, API routes, pages, server components, or middleware
+- `autoInstrumentServerFunctions`, `autoInstrumentMiddleware`, `autoInstrumentAppDirectory` — these are no-ops
+- `excludeServerRoutes` — no-op since routes aren't wrapped
+- React component name annotations
+- SentryWebpackPlugin (no webpack = no webpack plugin)
+
+Instrumentation with turbopack relies on **Next.js's built-in telemetry/OpenTelemetry integration** and the `instrumentation.ts` hook rather than build-time code transformation.
+
+## Config Flow
+
+```
+withSentryConfig(nextConfig, sentryOptions)
+  → detect bundler (webpack or turbopack)
+  → webpack:    constructWebpackConfigFunction() → loaders + plugins
+  → turbopack:  constructTurbopackConfig()       → value injection rules only
+  → set up runAfterProductionCompile hook (sourcemaps)
+```
+
+Entry point: `src/config/withSentryConfig/index.ts`
+Routing logic: `src/config/withSentryConfig/getFinalConfigObject.ts`
+
+## Key Directories
+
+| Path                           | Purpose                                                      |
+| ------------------------------ | ------------------------------------------------------------ |
+| `src/config/webpack.ts`        | Webpack-specific config (loaders, rules, plugins)            |
+| `src/config/turbopack/`        | Turbopack-specific config (value injection rules)            |
+| `src/config/loaders/`          | Webpack loaders (wrapping, value injection, module metadata) |
+| `src/config/templates/`        | Wrapper templates used by wrapping loader (webpack only)     |
+| `src/config/manifest/`         | Route manifest generation for transaction grouping           |
+| `src/config/withSentryConfig/` | Main `withSentryConfig` entry point and bundler routing      |
+| `src/client/`                  | Client-side SDK (browser)                                    |
+| `src/server/`                  | Server-side SDK (Node.js)                                    |
+| `src/edge/`                    | Edge runtime SDK                                             |