From 97acc21d1302f5a818721f67056760716b5fc6ec Mon Sep 17 00:00:00 2001
From: Pablo Deputter <pablo.deputter@sentry.io>
Date: Thu, 15 Oct 2026 14:57:55 +0200
Subject: [PATCH 1/4] .

---
 sentry_sdk/consts.py                          |  30 ++++
 sentry_sdk/integrations/boto3/_client.py      |   7 +-
 .../boto3/_services/stepfunctions.py          | 100 +++++++++--
 .../integrations/boto3/test_stepfunctions.py  | 161 +++++++++++++++++-
 4 files changed, 280 insertions(+), 18 deletions(-)

diff --git a/sentry_sdk/consts.py b/sentry_sdk/consts.py
index 5ff880ab73..48a98505ec 100644
--- a/sentry_sdk/consts.py
+++ b/sentry_sdk/consts.py
@@ -423,6 +423,36 @@ class SPANDATA:
     Example: "dfRtDYWFbkRONycy.Yxwh66Yjlx.cph0gtNBtJ"
     """
 
+    AWS_STEP_FUNCTIONS_ACTIVITY_ARN = "aws.step_functions.activity.arn"
+    """
+    The ARN of the AWS Step Functions activity the request refers to.
+    Example: "arn:aws:states:us-east-1:123456789012:activity:approve-order"
+    """
+
+    AWS_STEP_FUNCTIONS_ACTIVITY_NAME = "aws.step_functions.activity.name"
+    """
+    The name of the AWS Step Functions activity the request refers to.
+    Example: "approve-order"
+    """
+
+    AWS_STEP_FUNCTIONS_EXECUTION_ARN = "aws.step_functions.execution.arn"
+    """
+    The ARN of the AWS Step Functions execution the request refers to.
+    Example: "arn:aws:states:us-east-1:123456789012:execution:orders:4f9b1c2e"
+    """
+
+    AWS_STEP_FUNCTIONS_STATE_MACHINE_ARN = "aws.step_functions.state_machine.arn"
+    """
+    The ARN of the AWS Step Functions state machine the request refers to.
+    Example: "arn:aws:states:us-east-1:123456789012:stateMachine:orders"
+    """
+
+    AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME = "aws.step_functions.state_machine.name"
+    """
+    The name of the AWS Step Functions state machine the request refers to, without a version or alias qualifier.
+    Example: "orders"
+    """
+
     CACHE_HIT = "cache.hit"
     """
     A boolean indicating whether the requested data was found in the cache.
diff --git a/sentry_sdk/integrations/boto3/_client.py b/sentry_sdk/integrations/boto3/_client.py
index 10a5bb5c93..35ea846e22 100644
--- a/sentry_sdk/integrations/boto3/_client.py
+++ b/sentry_sdk/integrations/boto3/_client.py
@@ -2,6 +2,7 @@
 from typing import TYPE_CHECKING
 
 import sentry_sdk
+from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations import DidNotEnable
 from sentry_sdk.integrations.boto3._context import AwsCallContext
 from sentry_sdk.integrations.boto3._instrumentation import (
@@ -17,7 +18,7 @@
     _resolve_service,
 )
 from sentry_sdk.integrations.boto3.consts import IDENTIFIER
-from sentry_sdk.traces import NoOpSpan, Span
+from sentry_sdk.traces import NoOpSpan, Span, SpanStatus
 from sentry_sdk.utils import capture_internal_exceptions
 
 if TYPE_CHECKING:
@@ -125,6 +126,10 @@ def sentry_patched_make_api_call(
                     attributes.update(_get_response_attributes(parsed))
                 with capture_internal_exceptions():
                     span.set_attributes(attributes)
+                    # a service extension reports a failure that didn't raise, i.e. one
+                    # in a successful response, with `error.type`.
+                    if SPANDATA.ERROR_TYPE in attributes:
+                        span.status = SpanStatus.ERROR
         except BaseException as error:
             _finish_span(span, error)
             raise
diff --git a/sentry_sdk/integrations/boto3/_services/stepfunctions.py b/sentry_sdk/integrations/boto3/_services/stepfunctions.py
index 2c37397660..bfbafbb34c 100644
--- a/sentry_sdk/integrations/boto3/_services/stepfunctions.py
+++ b/sentry_sdk/integrations/boto3/_services/stepfunctions.py
@@ -1,30 +1,98 @@
 from typing import TYPE_CHECKING
 
+from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations.boto3._services.base import _ServiceExtension
-from sentry_sdk.integrations.boto3._utils import _get_aws_arn_attributes
+from sentry_sdk.integrations.boto3._utils import (
+    _extract_attributes,
+    _get_aws_arn_attributes,
+)
 from sentry_sdk.utils import capture_internal_exceptions
 
 if TYPE_CHECKING:
+    from typing import Any, Sequence, Tuple
+
     from sentry_sdk._types import Attributes
     from sentry_sdk.integrations.boto3._context import AwsCallContext
+    from sentry_sdk.integrations.boto3._utils import _AttributeSpec
+
+# the arns otel records from the request and the response, plus the execution's.
+# https://opentelemetry.io/docs/specs/semconv/registry/attributes/aws/#amazon-step-functions-attributes
+_ARN_ATTRIBUTES: "Sequence[_AttributeSpec]" = (
+    ("activityArn", SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_ARN),
+    ("executionArn", SPANDATA.AWS_STEP_FUNCTIONS_EXECUTION_ARN),
+    ("stateMachineArn", SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_ARN),
+)
+
+# request parameters with the arn of the resource a call acts on. a call takes at most
+# one, `ListExecutions` either a `mapRunArn` or a `stateMachineArn`.
+_TARGET_ARN_PARAMS = (
+    "activityArn",
+    "executionArn",
+    "mapRunArn",
+    "resourceArn",
+    "stateMachineAliasArn",
+    "stateMachineArn",
+    "stateMachineVersionArn",
+)
+
+# apis whose `name` is the name of what they create; elsewhere it names an execution
+# (often per order or customer) or an alias.
+_CREATED_NAME_ATTRIBUTES = {
+    "CreateActivity": SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME,
+    "CreateStateMachine": SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME,
+}
+
+# `StartSyncExecution` returns `200 OK` for a failed or timed out execution too.
+# https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartSyncExecution.html
+_SYNC_EXECUTION_ERROR_TYPES = {
+    "FAILED": "stepfunctions_execution_failed",
+    "TIMED_OUT": "stepfunctions_execution_timed_out",
+}
+
+
+def _get_name_attribute(arn: str) -> "Tuple[str, str]":
+    # `arn:<partition>:states:<region>:<account>:<type>:<name>…`, where <name> is the
+    # activity's or the state machine's. versions and aliases append `:<qualifier>`,
+    # executions `:<execution name>`; map runs and their child executions put `/<label>`
+    # after it. names can't contain ":" or "/".
+    # https://docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html
+    # https://docs.aws.amazon.com/step-functions/latest/dg/concepts-examine-map-run.html
+    # https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html#StepFunctions-CreateStateMachine-request-name
+    parts = arn.split(":", 7)
+    if parts[5] == "activity":
+        return SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME, parts[6]
+    return SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME, parts[6].split("/", 1)[0]
 
 
 class _StepFunctionsExtension(_ServiceExtension):
     def get_request_attributes(self, ctx: "AwsCallContext") -> "Attributes":
-        attributes: "Attributes" = {}
+        attributes: "Attributes" = _extract_attributes(ctx.params, _ARN_ATTRIBUTES)
         with capture_internal_exceptions():
-            attributes.update(
-                _get_aws_arn_attributes(
-                    (
-                        ctx.params.get("activityArn"),
-                        ctx.params.get("executionArn"),
-                        ctx.params.get("mapRunArn"),
-                        ctx.params.get("resourceArn"),
-                        ctx.params.get("stateMachineAliasArn"),
-                        ctx.params.get("stateMachineArn"),
-                        ctx.params.get("stateMachineVersionArn"),
-                    ),
-                    ("states",),
-                )
-            )
+            name_attribute = _CREATED_NAME_ATTRIBUTES.get(ctx.operation_name)
+            if name_attribute is not None:
+                attributes[name_attribute] = ctx.params["name"]
+
+            for param in _TARGET_ARN_PARAMS:
+                if param in ctx.params:
+                    arn = ctx.params[param]
+                    attributes.update(_get_aws_arn_attributes((arn,), ("states",)))
+                    name_attribute, name = _get_name_attribute(arn)
+                    attributes[name_attribute] = name
+                    break
+        return attributes
+
+    def get_response_attributes(
+        self, ctx: "AwsCallContext", response: "Any"
+    ) -> "Attributes":
+        # never `input`, `output`, `error` or `cause`.
+        attributes = _extract_attributes(response, _ARN_ATTRIBUTES)
+        # only `StartSyncExecution` runs the execution its `status` describes; a failed
+        # call has none.
+        if (
+            ctx.operation_name == "StartSyncExecution"
+            and response.get("status") in _SYNC_EXECUTION_ERROR_TYPES
+        ):
+            attributes[SPANDATA.ERROR_TYPE] = _SYNC_EXECUTION_ERROR_TYPES[
+                response["status"]
+            ]
         return attributes
diff --git a/tests/integrations/boto3/test_stepfunctions.py b/tests/integrations/boto3/test_stepfunctions.py
index e080effc46..393362ae1a 100644
--- a/tests/integrations/boto3/test_stepfunctions.py
+++ b/tests/integrations/boto3/test_stepfunctions.py
@@ -1,9 +1,44 @@
+from datetime import datetime, timezone
+
+import pytest
 from botocore.stub import Stubber
 
 from sentry_sdk.consts import OP, SPANDATA
-from tests.integrations.boto3.helpers import capture_spans_by_op
+from tests.integrations.boto3.helpers import (
+    capture_spans_by_op,
+    require_botocore_model_fields,
+)
 from tests.integrations.boto3.helpers import client_factory as client_factory
 
+ARN_PREFIX = "arn:aws:states:eu-north-1:123456789012:"
+STATE_MACHINE_ARN = ARN_PREFIX + "stateMachine:orders"
+EXECUTION_ARN = ARN_PREFIX + "execution:orders:order-1234"
+ACTIVITY_ARN = ARN_PREFIX + "activity:approve"
+DATE = datetime(2026, 10, 14, tzinfo=timezone.utc)
+
+STEP_FUNCTIONS_ATTRIBUTES = (
+    SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_ARN,
+    SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME,
+    SPANDATA.AWS_STEP_FUNCTIONS_EXECUTION_ARN,
+    SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_ARN,
+    SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME,
+)
+
+
+@pytest.fixture
+def stepfunctions_client(client_factory):
+    return client_factory("stepfunctions")
+
+
+def _stubbed_span(client, capture_items, method, params, response):
+    with Stubber(client) as stubber:
+        stubber.add_response(method, response, params)
+        spans = capture_spans_by_op(
+            lambda: getattr(client, method)(**params), capture_items
+        )
+    (span,) = spans[OP.RPC]
+    return span
+
 
 def test_request_attributes(client_factory, capture_items):
     client = client_factory("stepfunctions")
@@ -24,3 +59,127 @@ def test_request_attributes(client_factory, capture_items):
     attributes = span["attributes"]
     assert attributes[SPANDATA.CLOUD_ACCOUNT_ID] == "123456789012"
     assert attributes[SPANDATA.CLOUD_RESOURCE_ID] == state_machine_arn
+
+
+@pytest.mark.parametrize(
+    "method,params,response,expected",
+    [
+        pytest.param(
+            "start_execution",
+            {"stateMachineArn": STATE_MACHINE_ARN + ":prod", "name": "order-1234"},
+            {"executionArn": EXECUTION_ARN, "startDate": DATE},
+            {
+                SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_ARN: STATE_MACHINE_ARN
+                + ":prod",
+                SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME: "orders",
+                SPANDATA.AWS_STEP_FUNCTIONS_EXECUTION_ARN: EXECUTION_ARN,
+            },
+            id="alias",
+        ),
+        pytest.param(
+            "stop_execution",
+            {"executionArn": EXECUTION_ARN},
+            {"stopDate": DATE},
+            {
+                SPANDATA.AWS_STEP_FUNCTIONS_EXECUTION_ARN: EXECUTION_ARN,
+                SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME: "orders",
+            },
+            id="execution",
+        ),
+        pytest.param(
+            "list_executions",
+            {"mapRunArn": ARN_PREFIX + "mapRun:orders/process-items:5e7c"},
+            {"executions": []},
+            {SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME: "orders"},
+            id="map-run",
+        ),
+        pytest.param(
+            "create_state_machine",
+            {
+                "name": "orders",
+                "definition": "{}",
+                "roleArn": "arn:aws:iam::123456789012:role/orders",
+            },
+            {"stateMachineArn": STATE_MACHINE_ARN, "creationDate": DATE},
+            {
+                SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_ARN: STATE_MACHINE_ARN,
+                SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME: "orders",
+            },
+            id="create-state-machine",
+        ),
+        pytest.param(
+            "create_activity",
+            {"name": "approve"},
+            {"activityArn": ACTIVITY_ARN, "creationDate": DATE},
+            {
+                SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_ARN: ACTIVITY_ARN,
+                SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME: "approve",
+            },
+            id="create-activity",
+        ),
+        pytest.param(
+            "tag_resource",
+            {"resourceArn": ACTIVITY_ARN, "tags": [{"key": "team", "value": "a"}]},
+            {},
+            {SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME: "approve"},
+            id="tag-activity",
+        ),
+    ],
+)
+def test_resource_attributes(
+    stepfunctions_client, capture_items, method, params, response, expected
+):
+    require_botocore_model_fields(
+        stepfunctions_client, method, input_fields=tuple(params)
+    )
+    span = _stubbed_span(stepfunctions_client, capture_items, method, params, response)
+
+    attributes = span["attributes"]
+    assert {
+        key: value
+        for key, value in attributes.items()
+        if key in STEP_FUNCTIONS_ATTRIBUTES
+    } == expected
+
+
+@pytest.mark.parametrize(
+    "method,status,expected_error_type",
+    [
+        ("start_sync_execution", "SUCCEEDED", None),
+        ("start_sync_execution", "FAILED", "stepfunctions_execution_failed"),
+        ("start_sync_execution", "TIMED_OUT", "stepfunctions_execution_timed_out"),
+        # the status of an execution the call only describes.
+        ("describe_execution", "FAILED", None),
+    ],
+)
+def test_execution_outcome(
+    stepfunctions_client, capture_items, method, status, expected_error_type
+):
+    params = (
+        {"stateMachineArn": STATE_MACHINE_ARN, "input": '{"card": "4242"}'}
+        if method == "start_sync_execution"
+        else {"executionArn": EXECUTION_ARN}
+    )
+    response = {
+        "executionArn": EXECUTION_ARN,
+        "stateMachineArn": STATE_MACHINE_ARN,
+        "status": status,
+        "startDate": DATE,
+        "stopDate": DATE,
+        "error": "States.TaskFailed",
+        "cause": "card 4242 declined",
+    }
+    require_botocore_model_fields(
+        stepfunctions_client, method, output_fields=tuple(response)
+    )
+    span = _stubbed_span(stepfunctions_client, capture_items, method, params, response)
+
+    attributes = span["attributes"]
+    if expected_error_type is None:
+        assert span["status"] == "ok"
+        assert SPANDATA.ERROR_TYPE not in attributes
+    else:
+        assert span["status"] == "error"
+        assert attributes[SPANDATA.ERROR_TYPE] == expected_error_type
+    assert "4242" not in str(span)
+    assert "States.TaskFailed" not in str(span)

From 1c135e29c2a2370ce30d14d166c569adb2b6bac0 Mon Sep 17 00:00:00 2001
From: Pablo Deputter <pablo.deputter@sentry.io>
Date: Fri, 16 Oct 2026 17:51:29 +0200
Subject: [PATCH 2/4] wip

---
 .../boto3/_services/stepfunctions.py          | 28 +++++++++++--------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/sentry_sdk/integrations/boto3/_services/stepfunctions.py b/sentry_sdk/integrations/boto3/_services/stepfunctions.py
index bfbafbb34c..253380d435 100644
--- a/sentry_sdk/integrations/boto3/_services/stepfunctions.py
+++ b/sentry_sdk/integrations/boto3/_services/stepfunctions.py
@@ -67,18 +67,24 @@ def _get_name_attribute(arn: str) -> "Tuple[str, str]":
 class _StepFunctionsExtension(_ServiceExtension):
     def get_request_attributes(self, ctx: "AwsCallContext") -> "Attributes":
         attributes: "Attributes" = _extract_attributes(ctx.params, _ARN_ATTRIBUTES)
-        with capture_internal_exceptions():
-            name_attribute = _CREATED_NAME_ATTRIBUTES.get(ctx.operation_name)
-            if name_attribute is not None:
-                attributes[name_attribute] = ctx.params["name"]
 
-            for param in _TARGET_ARN_PARAMS:
-                if param in ctx.params:
-                    arn = ctx.params[param]
-                    attributes.update(_get_aws_arn_attributes((arn,), ("states",)))
-                    name_attribute, name = _get_name_attribute(arn)
-                    attributes[name_attribute] = name
-                    break
+        name_attribute = _CREATED_NAME_ATTRIBUTES.get(ctx.operation_name)
+        if name_attribute is not None and "name" in ctx.params:
+            attributes[name_attribute] = ctx.params["name"]
+
+        for param in _TARGET_ARN_PARAMS:
+            if param in ctx.params:
+                arn = ctx.params[param]
+                # `get_request_attributes()` runs before botocore validates the params;
+                # a malformed arn mustn't drop the other attributes.
+                with capture_internal_exceptions():
+                    arn_attributes = _get_aws_arn_attributes((arn,), ("states",))
+                    attributes.update(arn_attributes)
+                    if arn_attributes:
+                        name_attribute, name = _get_name_attribute(arn)
+                        attributes[name_attribute] = name
+                break
+
         return attributes
 
     def get_response_attributes(

From 18dc447f0f193869f513ab4f8ff7f66d0664d511 Mon Sep 17 00:00:00 2001
From: Pablo Deputter <pablo.deputter@sentry.io>
Date: Fri, 16 Oct 2026 18:24:28 +0200
Subject: [PATCH 3/4] simplify logic

---
 .../boto3/_services/stepfunctions.py          | 108 +++++++-----------
 1 file changed, 43 insertions(+), 65 deletions(-)

diff --git a/sentry_sdk/integrations/boto3/_services/stepfunctions.py b/sentry_sdk/integrations/boto3/_services/stepfunctions.py
index 253380d435..8311b5405e 100644
--- a/sentry_sdk/integrations/boto3/_services/stepfunctions.py
+++ b/sentry_sdk/integrations/boto3/_services/stepfunctions.py
@@ -9,96 +9,74 @@
 from sentry_sdk.utils import capture_internal_exceptions
 
 if TYPE_CHECKING:
-    from typing import Any, Sequence, Tuple
+    from typing import Any, Sequence
 
     from sentry_sdk._types import Attributes
     from sentry_sdk.integrations.boto3._context import AwsCallContext
     from sentry_sdk.integrations.boto3._utils import _AttributeSpec
 
-# the arns otel records from the request and the response, plus the execution's.
-# https://opentelemetry.io/docs/specs/semconv/registry/attributes/aws/#amazon-step-functions-attributes
+# set on both request and response if available.
 _ARN_ATTRIBUTES: "Sequence[_AttributeSpec]" = (
     ("activityArn", SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_ARN),
     ("executionArn", SPANDATA.AWS_STEP_FUNCTIONS_EXECUTION_ARN),
     ("stateMachineArn", SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_ARN),
 )
 
-# request parameters with the arn of the resource a call acts on. a call takes at most
-# one, `ListExecutions` either a `mapRunArn` or a `stateMachineArn`.
-_TARGET_ARN_PARAMS = (
-    "activityArn",
-    "executionArn",
-    "mapRunArn",
-    "resourceArn",
-    "stateMachineAliasArn",
-    "stateMachineArn",
-    "stateMachineVersionArn",
-)
-
-# apis whose `name` is the name of what they create; elsewhere it names an execution
-# (often per order or customer) or an alias.
-_CREATED_NAME_ATTRIBUTES = {
-    "CreateActivity": SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME,
-    "CreateStateMachine": SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME,
-}
-
-# `StartSyncExecution` returns `200 OK` for a failed or timed out execution too.
-# https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartSyncExecution.html
-_SYNC_EXECUTION_ERROR_TYPES = {
-    "FAILED": "stepfunctions_execution_failed",
-    "TIMED_OUT": "stepfunctions_execution_timed_out",
-}
-
-
-def _get_name_attribute(arn: str) -> "Tuple[str, str]":
-    # `arn:<partition>:states:<region>:<account>:<type>:<name>…`, where <name> is the
-    # activity's or the state machine's. versions and aliases append `:<qualifier>`,
-    # executions `:<execution name>`; map runs and their child executions put `/<label>`
-    # after it. names can't contain ":" or "/".
-    # https://docs.aws.amazon.com/step-functions/latest/dg/concepts-state-machine-version.html
-    # https://docs.aws.amazon.com/step-functions/latest/dg/concepts-examine-map-run.html
-    # https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html#StepFunctions-CreateStateMachine-request-name
-    parts = arn.split(":", 7)
-    if parts[5] == "activity":
-        return SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME, parts[6]
-    return SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME, parts[6].split("/", 1)[0]
-
 
 class _StepFunctionsExtension(_ServiceExtension):
     def get_request_attributes(self, ctx: "AwsCallContext") -> "Attributes":
         attributes: "Attributes" = _extract_attributes(ctx.params, _ARN_ATTRIBUTES)
 
-        name_attribute = _CREATED_NAME_ATTRIBUTES.get(ctx.operation_name)
-        if name_attribute is not None and "name" in ctx.params:
-            attributes[name_attribute] = ctx.params["name"]
+        # elsewhere `name` names an execution or an alias.
+        if "name" in ctx.params:
+            name = ctx.params["name"]
+            if ctx.operation_name == "CreateActivity":
+                attributes[SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME] = name
+            elif ctx.operation_name == "CreateStateMachine":
+                attributes[SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME] = name
 
-        for param in _TARGET_ARN_PARAMS:
+        for param in (
+            "activityArn",
+            "executionArn",
+            "mapRunArn",
+            "resourceArn",
+            "stateMachineAliasArn",
+            "stateMachineArn",
+            "stateMachineVersionArn",
+        ):
             if param in ctx.params:
                 arn = ctx.params[param]
-                # `get_request_attributes()` runs before botocore validates the params;
-                # a malformed arn mustn't drop the other attributes.
-                with capture_internal_exceptions():
-                    arn_attributes = _get_aws_arn_attributes((arn,), ("states",))
-                    attributes.update(arn_attributes)
-                    if arn_attributes:
-                        name_attribute, name = _get_name_attribute(arn)
-                        attributes[name_attribute] = name
                 break
+        else:
+            return attributes
+
+        # params aren't validated yet by botocore.
+        with capture_internal_exceptions():
+            arn_attributes = _get_aws_arn_attributes((arn,), ("states",))
+            attributes.update(arn_attributes)
+            if arn_attributes:
+                # `arn:<partition>:states:<region>:<account>:<type>:<name>…`; the name
+                # ends at the next ":" (version, alias, execution) or "/" (map run).
+                resource_type, resource = arn.split(":", 6)[5:]
+                name = resource.split(":", 1)[0].split("/", 1)[0]
+                if resource_type == "activity":
+                    attributes[SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME] = name
+                else:
+                    attributes[SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME] = name
 
         return attributes
 
     def get_response_attributes(
         self, ctx: "AwsCallContext", response: "Any"
     ) -> "Attributes":
-        # never `input`, `output`, `error` or `cause`.
         attributes = _extract_attributes(response, _ARN_ATTRIBUTES)
-        # only `StartSyncExecution` runs the execution its `status` describes; a failed
-        # call has none.
-        if (
-            ctx.operation_name == "StartSyncExecution"
-            and response.get("status") in _SYNC_EXECUTION_ERROR_TYPES
-        ):
-            attributes[SPANDATA.ERROR_TYPE] = _SYNC_EXECUTION_ERROR_TYPES[
-                response["status"]
-            ]
+
+        # `StartSyncExecution` returns `200 OK` even for failed/timed out executions.
+        # https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartSyncExecution.html
+        if ctx.operation_name == "StartSyncExecution":
+            if response.get("status") == "FAILED":
+                attributes[SPANDATA.ERROR_TYPE] = "stepfunctions_execution_failed"
+            elif response.get("status") == "TIMED_OUT":
+                attributes[SPANDATA.ERROR_TYPE] = "stepfunctions_execution_timed_out"
+
         return attributes

From e8d07b2d4f0575b7ed1133dbb290b61d3205df1a Mon Sep 17 00:00:00 2001
From: Pablo Deputter <pablo.deputter@sentry.io>
Date: Fri, 16 Oct 2026 18:33:20 +0200
Subject: [PATCH 4/4] remove uncessary test logic

---
 .../integrations/boto3/test_stepfunctions.py  | 92 ++++++-------------
 1 file changed, 30 insertions(+), 62 deletions(-)

diff --git a/tests/integrations/boto3/test_stepfunctions.py b/tests/integrations/boto3/test_stepfunctions.py
index 393362ae1a..f2ebc81eb7 100644
--- a/tests/integrations/boto3/test_stepfunctions.py
+++ b/tests/integrations/boto3/test_stepfunctions.py
@@ -12,25 +12,18 @@
 
 ARN_PREFIX = "arn:aws:states:eu-north-1:123456789012:"
 STATE_MACHINE_ARN = ARN_PREFIX + "stateMachine:orders"
+ALIAS_ARN = STATE_MACHINE_ARN + ":prod"
 EXECUTION_ARN = ARN_PREFIX + "execution:orders:order-1234"
+MAP_RUN_ARN = ARN_PREFIX + "mapRun:orders/process-items:5e7c"
 ACTIVITY_ARN = ARN_PREFIX + "activity:approve"
 DATE = datetime(2026, 10, 14, tzinfo=timezone.utc)
 
-STEP_FUNCTIONS_ATTRIBUTES = (
-    SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_ARN,
-    SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME,
-    SPANDATA.AWS_STEP_FUNCTIONS_EXECUTION_ARN,
-    SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_ARN,
-    SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME,
-)
-
-
-@pytest.fixture
-def stepfunctions_client(client_factory):
-    return client_factory("stepfunctions")
-
 
-def _stubbed_span(client, capture_items, method, params, response):
+def _stubbed_span(client_factory, capture_items, method, params, response):
+    client = client_factory("stepfunctions")
+    require_botocore_model_fields(
+        client, method, input_fields=tuple(params), output_fields=tuple(response)
+    )
     with Stubber(client) as stubber:
         stubber.add_response(method, response, params)
         spans = capture_spans_by_op(
@@ -40,37 +33,16 @@ def _stubbed_span(client, capture_items, method, params, response):
     return span
 
 
-def test_request_attributes(client_factory, capture_items):
-    client = client_factory("stepfunctions")
-    state_machine_arn = "arn:aws:states:eu-north-1:123456789012:stateMachine:orders"
-
-    with Stubber(client) as stubber:
-        stubber.add_response(
-            "delete_state_machine", {}, {"stateMachineArn": state_machine_arn}
-        )
-        spans = capture_spans_by_op(
-            lambda: client.delete_state_machine(
-                **{"stateMachineArn": state_machine_arn}
-            ),
-            capture_items,
-        )
-
-    (span,) = spans[OP.RPC]
-    attributes = span["attributes"]
-    assert attributes[SPANDATA.CLOUD_ACCOUNT_ID] == "123456789012"
-    assert attributes[SPANDATA.CLOUD_RESOURCE_ID] == state_machine_arn
-
-
 @pytest.mark.parametrize(
     "method,params,response,expected",
     [
         pytest.param(
             "start_execution",
-            {"stateMachineArn": STATE_MACHINE_ARN + ":prod", "name": "order-1234"},
+            {"stateMachineArn": ALIAS_ARN, "name": "order-1234"},
             {"executionArn": EXECUTION_ARN, "startDate": DATE},
             {
-                SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_ARN: STATE_MACHINE_ARN
-                + ":prod",
+                SPANDATA.CLOUD_RESOURCE_ID: ALIAS_ARN,
+                SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_ARN: ALIAS_ARN,
                 SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME: "orders",
                 SPANDATA.AWS_STEP_FUNCTIONS_EXECUTION_ARN: EXECUTION_ARN,
             },
@@ -81,6 +53,7 @@ def test_request_attributes(client_factory, capture_items):
             {"executionArn": EXECUTION_ARN},
             {"stopDate": DATE},
             {
+                SPANDATA.CLOUD_RESOURCE_ID: EXECUTION_ARN,
                 SPANDATA.AWS_STEP_FUNCTIONS_EXECUTION_ARN: EXECUTION_ARN,
                 SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME: "orders",
             },
@@ -88,9 +61,12 @@ def test_request_attributes(client_factory, capture_items):
         ),
         pytest.param(
             "list_executions",
-            {"mapRunArn": ARN_PREFIX + "mapRun:orders/process-items:5e7c"},
+            {"mapRunArn": MAP_RUN_ARN},
             {"executions": []},
-            {SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME: "orders"},
+            {
+                SPANDATA.CLOUD_RESOURCE_ID: MAP_RUN_ARN,
+                SPANDATA.AWS_STEP_FUNCTIONS_STATE_MACHINE_NAME: "orders",
+            },
             id="map-run",
         ),
         pytest.param(
@@ -121,24 +97,24 @@ def test_request_attributes(client_factory, capture_items):
             "tag_resource",
             {"resourceArn": ACTIVITY_ARN, "tags": [{"key": "team", "value": "a"}]},
             {},
-            {SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME: "approve"},
+            {
+                SPANDATA.CLOUD_RESOURCE_ID: ACTIVITY_ARN,
+                SPANDATA.AWS_STEP_FUNCTIONS_ACTIVITY_NAME: "approve",
+            },
             id="tag-activity",
         ),
     ],
 )
 def test_resource_attributes(
-    stepfunctions_client, capture_items, method, params, response, expected
+    client_factory, capture_items, method, params, response, expected
 ):
-    require_botocore_model_fields(
-        stepfunctions_client, method, input_fields=tuple(params)
-    )
-    span = _stubbed_span(stepfunctions_client, capture_items, method, params, response)
+    span = _stubbed_span(client_factory, capture_items, method, params, response)
 
-    attributes = span["attributes"]
+    # `cloud.resource_id` is only set from the arn in the request the call acts on.
     assert {
         key: value
-        for key, value in attributes.items()
-        if key in STEP_FUNCTIONS_ATTRIBUTES
+        for key, value in span["attributes"].items()
+        if key.startswith("aws.step_functions.") or key == SPANDATA.CLOUD_RESOURCE_ID
     } == expected
 
 
@@ -148,12 +124,11 @@ def test_resource_attributes(
         ("start_sync_execution", "SUCCEEDED", None),
         ("start_sync_execution", "FAILED", "stepfunctions_execution_failed"),
         ("start_sync_execution", "TIMED_OUT", "stepfunctions_execution_timed_out"),
-        # the status of an execution the call only describes.
         ("describe_execution", "FAILED", None),
     ],
 )
 def test_execution_outcome(
-    stepfunctions_client, capture_items, method, status, expected_error_type
+    client_factory, capture_items, method, status, expected_error_type
 ):
     params = (
         {"stateMachineArn": STATE_MACHINE_ARN, "input": '{"card": "4242"}'}
@@ -169,17 +144,10 @@ def test_execution_outcome(
         "error": "States.TaskFailed",
         "cause": "card 4242 declined",
     }
-    require_botocore_model_fields(
-        stepfunctions_client, method, output_fields=tuple(response)
-    )
-    span = _stubbed_span(stepfunctions_client, capture_items, method, params, response)
+    span = _stubbed_span(client_factory, capture_items, method, params, response)
 
-    attributes = span["attributes"]
-    if expected_error_type is None:
-        assert span["status"] == "ok"
-        assert SPANDATA.ERROR_TYPE not in attributes
-    else:
-        assert span["status"] == "error"
-        assert attributes[SPANDATA.ERROR_TYPE] == expected_error_type
+    assert span["status"] == ("ok" if expected_error_type is None else "error")
+    assert span["attributes"].get(SPANDATA.ERROR_TYPE) == expected_error_type
+    # the execution's input, error and cause are never recorded.
     assert "4242" not in str(span)
     assert "States.TaskFailed" not in str(span)