feat(aws-serverless): Emit low cardinality function.aws span names

`function.aws` spans were already named after the Lambda function, which is what the
`{{faas.name}}` template in the Sentry span name conventions asks for, so their names do
not change. What was missing is the conventions' static fallback: when the invocation
context carries no function name, the span was started with an empty name and `faas.name`
was left unset.

Resolve the function name from `context.functionName` or the `AWS_LAMBDA_FUNCTION_NAME`
environment variable, use it for both the span name and `faas.name`, and fall back to
`Serverless function execution` under span streaming. Without span streaming the name stays
byte-identical to before.

Refs #23954
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Lms24

MIGRATION.md

@@ -965,6 +965,7 @@ The following span names were adjusted:
 | `router`                                                                 | Framework-specific, sometimes containing the raw URL                                                      | `/users/123`, `SvelteKit Route Change`                                         | The span's `http.route`, or `Router` if the SDK has none                                                                                                                            | `/users/:id`, `Router`                                 |
 | `handler`                                                                | Framework-specific, often carrying the request method                                                     | `GET /users/:id`, `route-handler`, `getUser`                                   | The span's `http.route`, or `Request handler` if the SDK has none                                                                                                                   | `/users/:id`, `Request handler`                        |
 | `function.gcp`                                                           | The request method and path for HTTP functions, otherwise the trigger's event or trigger type             | `POST /users`, `google.pubsub.topic.publish`, `firebase.function.http.request` | The function name, or `Serverless function execution` if the SDK cannot resolve one                                                                                                 | `myFunction`, `Serverless function execution`          |
+| `function.aws`                                                           | The Lambda function name                                                                                  | `my-function`                                                                  | Unchanged, except that the SDK now falls back to `Serverless function execution` if it cannot resolve the function name                                                             | `my-function`, `Serverless function execution`         |
 | `graphql`                                                                | The graphql phase and, for operations, the operation name                                                 | `query GetUser`, `graphql.parse`, `graphql.resolve user.0.name`                | The operation type, or the processing type where there is none                                                                                                                      | `GraphQL query`, `GraphQL parse`, `GraphQL resolve`    |
 | `gen_ai.chat`, `gen_ai.embeddings`, `gen_ai.generate_content`            | `{operation} {model}`, or `{operation} unknown` if the model is missing                                   | `chat gpt-4`, `chat unknown`                                                   | `{operation} {model}`, or `{operation}` if the model is missing                                                                                                                     | `chat gpt-4`, `chat`                                   |
 | `gen_ai.invoke_agent`                                                    | The LangChain chain name, prefixed with `chain` rather than the operation                                 | `chain format_prompt`, `chain unknown_chain`                                   | `{operation} {name}`, where the name is the span's `gen_ai.agent.name`, `gen_ai.pipeline.name` or `gen_ai.function_id`, in that order, or `{operation}` if the span carries none    | `invoke_agent format_prompt`, `invoke_agent`           |
@@ -992,6 +993,13 @@ Whatever the name no longer carries stays on the span as an attribute:
 - `gcp.function.context.*` — the fields of the trigger event, including the event type the span used to be named after.
 - `http.request.method` and `url.path` — for HTTP-triggered functions, the method and path the span used to be named after.
 
+`function.aws` spans in `@sentry/aws-serverless` were already named after the Lambda function, so
+their names are unchanged. The only new behaviour is the fallback: if neither the invocation context
+nor the `AWS_LAMBDA_FUNCTION_NAME` environment variable yields a function name, the span is named
+`Serverless function execution` instead of carrying an empty name. These spans continue to carry the
+function name on `faas.name`, the request URL on `url.full`, and the invocation details on
+`aws.lambda.*` and `aws.cloudwatch.logs.*`.
+
 #### Filtering and sampling
 
 When span streaming is enabled (i.e. by default) `ignoreSpans` is evaluated when a span **starts**, at which point a span might not yet have its final name:

packages/aws-serverless/src/requestSpanOptions.ts

@@ -28,7 +28,13 @@ import {
 } from '@sentry/conventions/attributes';
 import { FUNCTION_AWS } from '@sentry/conventions/op';
 import type { SpanAttributes, StartSpanOptions } from '@sentry/core';
-import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, filterCollectedUrl } from '@sentry/core';
+import {
+  getClient,
+  hasSpanStreamingEnabled,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  SERVERLESS_FUNCTION_SPAN_NAME_FALLBACK,
+  filterCollectedUrl,
+} from '@sentry/core';
 import type { Context } from 'aws-lambda';
 import { ATTR_FAAS_EXECUTION, ATTR_FAAS_ID } from './semconv';
 
@@ -43,9 +49,16 @@ interface ApiGatewayLikeEvent {
  * Builds the options for the `function.aws` transaction started for each invocation.
  */
 export function getRequestSpanOptions(event: unknown, context: Context, requestIsColdStart: boolean): StartSpanOptions {
+  const client = getClient();
+
+  const functionName = getFunctionName(context);
+
   // The span is started within the surrounding `continueTrace`, so it continues the incoming trace.
   return {
-    name: context.functionName,
+    name:
+      client && hasSpanStreamingEnabled(client)
+        ? functionName || SERVERLESS_FUNCTION_SPAN_NAME_FALLBACK
+        : context.functionName,
     attributes: {
       [SENTRY_OP]: FUNCTION_AWS,
       [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.aws_lambda',
@@ -55,13 +68,23 @@ export function getRequestSpanOptions(event: unknown, context: Context, requestI
       [CLOUD_ACCOUNT_ID]: extractAccountId(context.invokedFunctionArn),
       [CLOUD_PROVIDER]: 'aws',
       [CLOUD_PLATFORM]: 'aws_lambda',
-      [FAAS_NAME]: context.functionName,
+      [FAAS_NAME]: functionName,
       [FAAS_COLDSTART]: requestIsColdStart,
       ...extractOtherEventFields(event),
     },
   };
 }
 
+/**
+ * Resolves the name of the currently executing Lambda function.
+ *
+ * The runtime always populates `context.functionName`; `AWS_LAMBDA_FUNCTION_NAME` covers custom
+ * runtimes and local emulators that only partially fill in the invocation context.
+ */
+function getFunctionName(context: Context): string | undefined {
+  return context.functionName || process.env.AWS_LAMBDA_FUNCTION_NAME || undefined;
+}
+
 function extractAccountId(arn: string): string | undefined {
   const parts = arn.split(':');
   if (parts.length >= 5) {

packages/aws-serverless/test/requestSpanOptions.test.ts

@@ -0,0 +1,113 @@
+import {
+  CLOUD_ACCOUNT_ID,
+  CLOUD_PLATFORM,
+  CLOUD_PROVIDER,
+  FAAS_COLDSTART,
+  FAAS_NAME,
+  SENTRY_KIND,
+  SENTRY_OP,
+  URL_FULL,
+} from '@sentry/conventions/attributes';
+import { FUNCTION_AWS } from '@sentry/conventions/op';
+import type { Client } from '@sentry/core';
+import * as SentryCore from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SERVERLESS_FUNCTION_SPAN_NAME_FALLBACK } from '@sentry/core';
+import type { Context } from 'aws-lambda';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { getRequestSpanOptions } from '../src/requestSpanOptions';
+
+function createContext(overrides: Partial<Context> = {}): Context {
+  return {
+    functionName: 'my-function',
+    functionVersion: '$LATEST',
+    invokedFunctionArn: 'arn:aws:lambda:us-east-1:012345678912:function:my-function',
+    awsRequestId: '1e1cd0dc-6bd0-4e0e-9a5d-63e8c7bd4b3b',
+    ...overrides,
+  } as Context;
+}
+
+function mockSpanStreaming(enabled: boolean): void {
+  vi.spyOn(SentryCore, 'getClient').mockReturnValue({
+    getOptions: () => ({ traceLifecycle: enabled ? 'stream' : 'static' }),
+  } as unknown as Client);
+}
+
+describe('getRequestSpanOptions', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllEnvs();
+  });
+
+  test('names the span after the function and sets the invocation attributes', () => {
+    mockSpanStreaming(false);
+
+    expect(getRequestSpanOptions({}, createContext(), true)).toEqual({
+      name: 'my-function',
+      attributes: {
+        [SENTRY_OP]: FUNCTION_AWS,
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.aws_lambda',
+        [SENTRY_KIND]: 'server',
+        'faas.execution': '1e1cd0dc-6bd0-4e0e-9a5d-63e8c7bd4b3b',
+        'faas.id': 'arn:aws:lambda:us-east-1:012345678912:function:my-function',
+        [CLOUD_ACCOUNT_ID]: '012345678912',
+        [CLOUD_PROVIDER]: 'aws',
+        [CLOUD_PLATFORM]: 'aws_lambda',
+        [FAAS_NAME]: 'my-function',
+        [FAAS_COLDSTART]: true,
+      },
+    });
+  });
+
+  test.each([true, false])('names the span after the function with span streaming %s', spanStreamingEnabled => {
+    mockSpanStreaming(spanStreamingEnabled);
+
+    const spanOptions = getRequestSpanOptions({}, createContext(), false);
+
+    expect(spanOptions.name).toBe('my-function');
+    expect(spanOptions.attributes?.[FAAS_NAME]).toBe('my-function');
+  });
+
+  test('keeps the API gateway URL on an attribute rather than in the name', () => {
+    mockSpanStreaming(true);
+
+    const event = {
+      headers: { host: 'api.example.com', 'x-forwarded-proto': 'https' },
+      path: '/users/123',
+      queryStringParameters: { expand: 'profile' },
+    };
+
+    const spanOptions = getRequestSpanOptions(event, createContext(), false);
+
+    expect(spanOptions.name).toBe('my-function');
+    expect(spanOptions.attributes?.[URL_FULL]).toBe('https://api.example.com/users/123?expand=profile');
+  });
+
+  test('falls back to AWS_LAMBDA_FUNCTION_NAME when the context has no function name', () => {
+    mockSpanStreaming(true);
+    vi.stubEnv('AWS_LAMBDA_FUNCTION_NAME', 'my-env-function');
+
+    const spanOptions = getRequestSpanOptions({}, createContext({ functionName: '' }), false);
+
+    expect(spanOptions.name).toBe('my-env-function');
+    expect(spanOptions.attributes?.[FAAS_NAME]).toBe('my-env-function');
+  });
+
+  test('falls back to the static span name when no function name is resolvable', () => {
+    mockSpanStreaming(true);
+    vi.stubEnv('AWS_LAMBDA_FUNCTION_NAME', '');
+
+    const spanOptions = getRequestSpanOptions({}, createContext({ functionName: '' }), false);
+
+    expect(spanOptions.name).toBe(SERVERLESS_FUNCTION_SPAN_NAME_FALLBACK);
+    expect(spanOptions.attributes?.[FAAS_NAME]).toBeUndefined();
+  });
+
+  test('keeps the unresolved function name without span streaming', () => {
+    mockSpanStreaming(false);
+    vi.stubEnv('AWS_LAMBDA_FUNCTION_NAME', '');
+
+    const spanOptions = getRequestSpanOptions({}, createContext({ functionName: '' }), false);
+
+    expect(spanOptions.name).toBe('');
+  });
+});