⚡️ Speed up function get_start_span_function by 18%

[codeflash-ai]

📄 18% (0.18x) speedup for get_start_span_function in sentry_sdk/ai/utils.py

⏱️ Runtime : 4.22 milliseconds → 3.59 milliseconds (best of 146 runs)

📝 Explanation and details

The optimization replaces the indirect function call in get_current_span() with direct inline logic, eliminating function call overhead and reducing stack depth.

What changed:

• Removed function indirection: Instead of calling tracing_utils.get_current_span(scope), the optimized version directly implements the same logic inline
• Eliminated redundant scope resolution: The original version had two levels of scope resolution (once in api.py → tracing_utils.py, then again internally), while the optimized version does it once

Why it's faster:

• Reduced call stack depth: Eliminates the intermediate function call to tracing_utils.get_current_span(), saving function call overhead (~100-200ns per call)
• Direct attribute access: scope.span is accessed directly instead of going through another function that does the same operation
• Better CPU cache efficiency: Fewer function boundaries means better instruction cache locality

Performance characteristics:
The optimization shows 17% overall speedup and is particularly effective for:

• High-frequency span checking scenarios (evident in large-scale test cases showing 17-21% improvements)
• Applications that frequently call get_current_span() indirectly through get_start_span_function()
• Cases where scope resolution happens repeatedly in tight loops

The line profiler shows the get_current_span function time dropped from 16.86ms to 15.29ms, with the optimization eliminating the function call overhead that was the primary bottleneck in this hot path.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 5044 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 1 Passed
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

from types import SimpleNamespace

# imports
import pytest  # used for our unit tests
from sentry_sdk.ai.utils import get_start_span_function

# Function to test and minimal sentry_sdk stubs for isolated testing

# --- Minimal Sentry SDK Stubs for Testing ---

class DummyTransaction:
    def __init__(self):
        self.containing_transaction = self  # Transaction contains itself

class DummySpan:
    def __init__(self, containing_transaction=None):
        # If containing_transaction is None, it's not inside a transaction
        self.containing_transaction = containing_transaction

class DummyScope:
    def __init__(self, span=None):
        self.span = span

    def start_span(self, **kwargs):
        return "span"

    def start_transaction(self, *args, **kwargs):
        return "transaction"

# Global mutable state for test isolation
class DummySentrySDK:
    _current_scope = DummyScope()
    _get_current_span_override = None

    @classmethod
    def get_current_scope(cls):
        return cls._current_scope

    @classmethod
    def set_scope(cls, scope):
        cls._current_scope = scope

    @classmethod
    def get_current_span(cls, scope=None):
        if cls._get_current_span_override is not None:
            return cls._get_current_span_override()
        scope = scope or cls.get_current_scope()
        return scope.span

    @classmethod
    def set_get_current_span_override(cls, func):
        cls._get_current_span_override = func

    @classmethod
    def clear_get_current_span_override(cls):
        cls._get_current_span_override = None

    @classmethod
    def start_span(cls, **kwargs):
        return "span"

    @classmethod
    def start_transaction(cls, *args, **kwargs):
        return "transaction"
from sentry_sdk.ai.utils import get_start_span_function

# --- Unit Tests ---

# 1. Basic Test Cases

def test_returns_start_transaction_when_no_span():
    # No span in scope: should return start_transaction
    DummySentrySDK.set_scope(DummyScope(span=None))
    codeflash_output = get_start_span_function(); func = codeflash_output # 14.1μs -> 13.7μs (2.65% faster)

def test_returns_start_transaction_when_span_without_transaction():
    # Span exists but not inside a transaction
    span = DummySpan(containing_transaction=None)
    DummySentrySDK.set_scope(DummyScope(span=span))
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.4μs -> 12.2μs (2.26% faster)

def test_returns_start_span_when_span_with_transaction():
    # Span exists and is inside a transaction
    transaction = DummyTransaction()
    span = DummySpan(containing_transaction=transaction)
    DummySentrySDK.set_scope(DummyScope(span=span))
    codeflash_output = get_start_span_function(); func = codeflash_output # 11.0μs -> 12.1μs (9.01% slower)

def test_returns_start_span_when_span_containing_transaction_is_self():
    # Span's containing_transaction is itself (common for root transaction spans)
    span = DummySpan()
    span.containing_transaction = span
    DummySentrySDK.set_scope(DummyScope(span=span))
    codeflash_output = get_start_span_function(); func = codeflash_output # 11.8μs -> 11.8μs (0.195% slower)

# 2. Edge Test Cases

def test_returns_start_transaction_when_span_is_weird_object():
    # Span is an object without containing_transaction attribute
    class WeirdSpan:
        pass
    DummySentrySDK.set_scope(DummyScope(span=WeirdSpan()))
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.3μs -> 12.3μs (0.591% slower)

def test_returns_start_transaction_when_span_containing_transaction_is_none():
    # Span's containing_transaction is explicitly None
    class SpanWithNone:
        containing_transaction = None
    DummySentrySDK.set_scope(DummyScope(span=SpanWithNone()))
    codeflash_output = get_start_span_function(); func = codeflash_output # 11.9μs -> 12.4μs (4.61% slower)

def test_returns_start_span_when_span_containing_transaction_is_truthy_object():
    # containing_transaction is a truthy non-None object
    class FakeTransaction:
        pass
    class Span:
        containing_transaction = FakeTransaction()
    DummySentrySDK.set_scope(DummyScope(span=Span()))
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.1μs -> 11.8μs (2.50% faster)

def test_returns_start_transaction_when_get_current_span_returns_none():
    # get_current_span returns None directly (simulate override)
    DummySentrySDK.set_get_current_span_override(lambda: None)
    codeflash_output = get_start_span_function(); func = codeflash_output # 11.9μs -> 11.4μs (4.43% faster)

def test_returns_start_span_when_get_current_span_returns_span_with_transaction():
    # get_current_span returns a span with containing_transaction
    DummySentrySDK.set_get_current_span_override(lambda: DummySpan(containing_transaction=DummyTransaction()))
    codeflash_output = get_start_span_function(); func = codeflash_output # 11.9μs -> 11.2μs (6.06% faster)

def test_returns_start_transaction_when_span_is_falsey_but_has_containing_transaction():
    # Span is a falsey object but has containing_transaction
    class FalseySpan:
        def __bool__(self): return False
        containing_transaction = DummyTransaction()
    DummySentrySDK.set_scope(DummyScope(span=FalseySpan()))
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.0μs -> 12.1μs (1.37% slower)

def test_returns_start_transaction_when_span_is_falsey_and_no_containing_transaction():
    # Span is a falsey object and containing_transaction is None
    class FalseySpan:
        def __bool__(self): return False
        containing_transaction = None
    DummySentrySDK.set_scope(DummyScope(span=FalseySpan()))
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.1μs -> 12.1μs (0.050% faster)

def test_returns_start_transaction_when_span_is_missing():
    # Scope has no span attribute at all
    class NoSpanScope:
        pass
    DummySentrySDK.set_scope(NoSpanScope())
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.2μs -> 12.0μs (1.34% faster)

def test_returns_start_transaction_when_span_is_explicitly_set_to_none():
    # Scope.span is explicitly None
    DummySentrySDK.set_scope(DummyScope(span=None))
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.0μs -> 12.0μs (0.502% faster)

# 3. Large Scale Test Cases

def test_many_scopes_with_mixed_spans():
    # Test with a large number of scopes, alternating between transaction and non-transaction
    for i in range(1000):
        if i % 2 == 0:
            # Even: span with transaction
            span = DummySpan(containing_transaction=DummyTransaction())
            DummySentrySDK.set_scope(DummyScope(span=span))
            codeflash_output = get_start_span_function(); func = codeflash_output
        else:
            # Odd: span without transaction
            span = DummySpan(containing_transaction=None)
            DummySentrySDK.set_scope(DummyScope(span=span))
            codeflash_output = get_start_span_function(); func = codeflash_output

def test_large_number_of_falsey_spans():
    # Test with many falsey spans, some with containing_transaction, some without
    class FalseySpan:
        def __init__(self, has_transaction):
            self.containing_transaction = DummyTransaction() if has_transaction else None
        def __bool__(self):
            return False
    for i in range(500):
        span = FalseySpan(has_transaction=(i % 2 == 0))
        DummySentrySDK.set_scope(DummyScope(span=span))
        codeflash_output = get_start_span_function(); func = codeflash_output # 387μs -> 330μs (17.3% faster)
        if i % 2 == 0:
            pass
        else:
            pass

def test_performance_with_large_scope_tree():
    # Simulate a deep call chain where only the innermost scope has a transaction
    # (simulate by changing the span in the DummyScope)
    for i in range(999, -1, -1):
        if i == 0:
            span = DummySpan(containing_transaction=DummyTransaction())
        else:
            span = DummySpan(containing_transaction=None)
        DummySentrySDK.set_scope(DummyScope(span=span))
        codeflash_output = get_start_span_function(); func = codeflash_output # 782μs -> 650μs (20.2% faster)
        if i == 0:
            pass
        else:
            pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from types import SimpleNamespace

# imports
import pytest  # used for our unit tests
from sentry_sdk.ai.utils import get_start_span_function

# --- Minimal stubs for sentry_sdk and dependencies for testability ---

# Simulate INSTRUMENTER enum
class INSTRUMENTER:
    SENTRY = "sentry"

# Simulate a Span and Transaction class
class Span:
    def __init__(self, containing_transaction=None):
        self.containing_transaction = containing_transaction

    def start_child(self, **kwargs):
        return Span(containing_transaction=self.containing_transaction)

    def finish(self):
        pass

class Transaction(Span):
    def __init__(self):
        super().__init__(containing_transaction=self)

# Simulate a Scope class with span attribute and methods
class Scope:
    _current_scope = None

    def __init__(self):
        self.span = None

    @classmethod
    def get_current_scope(cls):
        if cls._current_scope is None:
            cls._current_scope = Scope()
        return cls._current_scope

    def start_span(self, **kwargs):
        # Return a child span of the current transaction
        if self.span and self.span.containing_transaction:
            return Span(containing_transaction=self.span.containing_transaction)
        # If no transaction, create a span with no containing_transaction
        return Span()

    def start_transaction(self, transaction=None, instrumenter=INSTRUMENTER.SENTRY, custom_sampling_context=None, **kwargs):
        # Always create and set a new transaction
        txn = Transaction()
        self.span = txn
        return txn

# Simulate sentry_sdk module
class sentry_sdk:
    Scope = Scope

    @staticmethod
    def get_current_scope():
        return Scope.get_current_scope()

    @staticmethod
    def start_span(**kwargs):
        return sentry_sdk.get_current_scope().start_span(**kwargs)

    @staticmethod
    def start_transaction(transaction=None, instrumenter=INSTRUMENTER.SENTRY, custom_sampling_context=None, **kwargs):
        return sentry_sdk.get_current_scope().start_transaction(
            transaction, instrumenter, custom_sampling_context, **kwargs
        )

    @staticmethod
    def get_current_span(scope=None):
        scope = scope or sentry_sdk.get_current_scope()
        return scope.span
from sentry_sdk.ai.utils import get_start_span_function

# --- Unit Tests ---

# Basic Test Cases

def test_returns_start_transaction_when_no_span():
    """
    If there is no current span, should return start_transaction.
    """
    scope = sentry_sdk.get_current_scope()
    scope.span = None  # No current span
    codeflash_output = get_start_span_function(); func = codeflash_output # 16.9μs -> 16.2μs (4.20% faster)

def test_returns_start_transaction_when_span_without_transaction():
    """
    If there is a current span but it has no containing_transaction, should return start_transaction.
    """
    scope = sentry_sdk.get_current_scope()
    scope.span = Span(containing_transaction=None)
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.5μs -> 11.9μs (5.33% faster)

def test_returns_start_span_when_span_with_transaction():
    """
    If there is a current span with a containing_transaction, should return start_span.
    """
    scope = sentry_sdk.get_current_scope()
    txn = Transaction()
    scope.span = Span(containing_transaction=txn)
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.0μs -> 12.2μs (1.51% slower)

def test_returns_start_span_when_current_span_is_transaction():
    """
    If the current span is itself a transaction, should return start_span.
    """
    scope = sentry_sdk.get_current_scope()
    txn = Transaction()
    scope.span = txn
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.2μs -> 12.1μs (1.36% faster)

# Edge Test Cases

def test_span_with_falsy_but_non_none_containing_transaction():
    """
    If containing_transaction is a falsy value but not None, should still return start_span.
    """
    scope = sentry_sdk.get_current_scope()
    # containing_transaction is 0 (falsy, but not None)
    scope.span = Span(containing_transaction=0)
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.1μs -> 12.0μs (0.517% faster)

def test_span_with_containing_transaction_set_to_empty_object():
    """
    If containing_transaction is an empty object, should return start_span.
    """
    scope = sentry_sdk.get_current_scope()
    scope.span = Span(containing_transaction={})
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.0μs -> 12.0μs (0.208% faster)

def test_span_with_missing_containing_transaction_attribute():
    """
    If span has no containing_transaction attribute, should return start_transaction.
    """
    class OddSpan:
        pass
    scope = sentry_sdk.get_current_scope()
    scope.span = OddSpan()
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.9μs -> 12.4μs (3.65% faster)

def test_span_with_containing_transaction_set_to_false():
    """
    If containing_transaction is False, should return start_span.
    """
    scope = sentry_sdk.get_current_scope()
    scope.span = Span(containing_transaction=False)
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.2μs -> 11.7μs (3.82% faster)

def test_span_object_is_not_span_but_has_containing_transaction():
    """
    If span is not a Span instance but has a containing_transaction attribute, should return start_span.
    """
    class FakeSpan:
        def __init__(self):
            self.containing_transaction = "txn"
    scope = sentry_sdk.get_current_scope()
    scope.span = FakeSpan()
    codeflash_output = get_start_span_function(); func = codeflash_output # 12.4μs -> 12.1μs (2.44% faster)

def test_span_object_is_not_span_and_no_containing_transaction():
    """
    If span is not a Span instance and has no containing_transaction, should return start_transaction.
    """
    class FakeSpan:
        pass
    scope = sentry_sdk.get_current_scope()
    scope.span = FakeSpan()
    codeflash_output = get_start_span_function(); func = codeflash_output # 11.4μs -> 11.5μs (0.619% slower)

# Large Scale Test Cases

def test_large_number_of_transactions_and_spans():
    """
    Test with a large number of transactions and spans to ensure performance and correctness.
    """
    scope = sentry_sdk.get_current_scope()
    # Create 500 transactions and 500 child spans
    for i in range(500):
        txn = Transaction()
        scope.span = txn
        codeflash_output = get_start_span_function(); func = codeflash_output # 402μs -> 337μs (19.3% faster)
        # Now set span to a child span with transaction
        child = Span(containing_transaction=txn)
        scope.span = child
        codeflash_output = get_start_span_function(); func = codeflash_output # 382μs -> 318μs (20.3% faster)
        # Now set span to a child span without transaction
        orphan = Span(containing_transaction=None)
        scope.span = orphan
        codeflash_output = get_start_span_function(); func = codeflash_output

def test_performance_with_many_span_switches():
    """
    Rapidly switch between spans with and without transactions to check for correctness and speed.
    """
    scope = sentry_sdk.get_current_scope()
    for i in range(1000):
        if i % 2 == 0:
            scope.span = Span(containing_transaction=Transaction())
            codeflash_output = get_start_span_function()
        else:
            scope.span = Span(containing_transaction=None)
            codeflash_output = get_start_span_function()

def test_span_with_large_containing_transaction_object():
    """
    Test with a very large containing_transaction object.
    """
    class LargeTransaction:
        def __init__(self):
            self.data = [0] * 999  # Large, but <1000 elements
    scope = sentry_sdk.get_current_scope()
    scope.span = Span(containing_transaction=LargeTransaction())
    codeflash_output = get_start_span_function(); func = codeflash_output # 14.9μs -> 16.0μs (6.74% slower)

# Additional edge: ensure function is deterministic
def test_determinism_over_multiple_calls():
    """
    The function should always return the same result for the same input state.
    """
    scope = sentry_sdk.get_current_scope()
    txn = Transaction()
    scope.span = txn
    for _ in range(10):
        codeflash_output = get_start_span_function() # 19.6μs -> 18.8μs (4.48% faster)
    scope.span = Span(containing_transaction=None)
    for _ in range(10):
        codeflash_output = get_start_span_function() # 7.52μs -> 6.19μs (21.4% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from sentry_sdk.ai.utils import get_start_span_function
from sentry_sdk.api import start_transaction

def test_get_start_span_function():
    get_start_span_function()

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_j2vbhl1v/tmpy0ye3j9e/test_concolic_coverage.py::test_get_start_span_function	12.1μs	12.8μs	-5.14%⚠️

To edit these changes git checkout codeflash/optimize-get_start_span_function-mg9uw59i and push.