⚡️ Speed up function _get_span_op by 128%

[codeflash-ai]

📄 128% (1.28x) speedup for _get_span_op in sentry_sdk/tracing_utils.py

⏱️ Runtime : 8.39 milliseconds → 3.67 milliseconds (best of 38 runs)

📝 Explanation and details

The optimization moves the dictionary mapping from inside the function to module-level as a constant _MAPPING. This eliminates the overhead of recreating the dictionary on every function call.

Key changes:

• Dictionary creation moved from function scope to module scope as _MAPPING
• Function now simply references the pre-existing dictionary instead of creating it

Why this is faster:
In Python, dictionary creation involves memory allocation and key-value pair insertion operations that occur every time the function is called. By moving the mapping to module level, it's created only once when the module is imported, then reused for all subsequent function calls. This removes the dictionary creation overhead entirely from the hot path.

Performance characteristics:
The optimization shows consistent 90-173% speedup across all test cases, with particularly strong gains for:

• Edge cases with non-template inputs (130-173% faster) - benefits most from avoiding unnecessary dictionary creation
• Bulk operations processing many templates (119-138% faster) - cumulative savings from eliminating repeated dictionary creation
• Both valid template lookups and default fallbacks see similar gains, indicating the bottleneck was dictionary creation rather than lookup operations

This is a classic Python optimization pattern where moving expensive object creation out of frequently-called functions to module initialization provides substantial performance benefits.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from enum import Enum  # used to define OP and SPANTEMPLATE enums
from typing import Union  # used for type hints

# imports
import pytest  # used for our unit tests
from sentry_sdk.tracing_utils import _get_span_op


# function to test
# Simulate sentry_sdk.consts.OP and SPANTEMPLATE for testing purposes
class OP(str, Enum):
    GEN_AI_CHAT = "gen.ai.chat"
    GEN_AI_INVOKE_AGENT = "gen.ai.invoke_agent"
    GEN_AI_EXECUTE_TOOL = "gen.ai.execute_tool"
    FUNCTION = "function"

class SPANTEMPLATE(str, Enum):
    AI_CHAT = "ai_chat"
    AI_AGENT = "ai_agent"
    AI_TOOL = "ai_tool"
from sentry_sdk.tracing_utils import _get_span_op

# unit tests

# ----------- BASIC TEST CASES -----------
def test_basic_ai_chat_enum():
    # Should map SPANTEMPLATE.AI_CHAT to OP.GEN_AI_CHAT
    codeflash_output = _get_span_op(SPANTEMPLATE.AI_CHAT) # 2.69μs -> 1.22μs (121% faster)

def test_basic_ai_agent_enum():
    # Should map SPANTEMPLATE.AI_AGENT to OP.GEN_AI_INVOKE_AGENT
    codeflash_output = _get_span_op(SPANTEMPLATE.AI_AGENT) # 2.12μs -> 975ns (117% faster)

def test_basic_ai_tool_enum():
    # Should map SPANTEMPLATE.AI_TOOL to OP.GEN_AI_EXECUTE_TOOL
    codeflash_output = _get_span_op(SPANTEMPLATE.AI_TOOL) # 1.92μs -> 1.01μs (90.7% faster)

def test_basic_ai_chat_str():
    # Should map string "ai_chat" to OP.GEN_AI_CHAT
    codeflash_output = _get_span_op("ai_chat") # 2.02μs -> 997ns (103% faster)

def test_basic_ai_agent_str():
    # Should map string "ai_agent" to OP.GEN_AI_INVOKE_AGENT
    codeflash_output = _get_span_op("ai_agent") # 1.97μs -> 911ns (116% faster)

def test_basic_ai_tool_str():
    # Should map string "ai_tool" to OP.GEN_AI_EXECUTE_TOOL
    codeflash_output = _get_span_op("ai_tool") # 1.95μs -> 969ns (101% faster)

def test_basic_unmapped_string():
    # Should default to OP.FUNCTION for unknown string
    codeflash_output = _get_span_op("not_a_template") # 1.95μs -> 819ns (138% faster)


def test_edge_empty_string():
    # Should default to OP.FUNCTION for empty string
    codeflash_output = _get_span_op("") # 2.02μs -> 825ns (145% faster)

def test_edge_none():
    # Should default to OP.FUNCTION for None input
    codeflash_output = _get_span_op(None) # 2.00μs -> 730ns (173% faster)

def test_edge_integer():
    # Should default to OP.FUNCTION for integer input
    codeflash_output = _get_span_op(123) # 1.87μs -> 815ns (130% faster)

def test_edge_float():
    # Should default to OP.FUNCTION for float input
    codeflash_output = _get_span_op(3.14) # 2.19μs -> 1.02μs (116% faster)

def test_edge_bool_true():
    # Should default to OP.FUNCTION for boolean True
    codeflash_output = _get_span_op(True) # 1.88μs -> 806ns (133% faster)

def test_edge_bool_false():
    # Should default to OP.FUNCTION for boolean False
    codeflash_output = _get_span_op(False) # 1.91μs -> 800ns (139% faster)



def test_edge_bytes():
    # Should default to OP.FUNCTION for bytes input
    codeflash_output = _get_span_op(b'ai_chat') # 3.52μs -> 1.84μs (91.6% faster)

def test_edge_case_sensitive():
    # Should default to OP.FUNCTION for case mismatch
    codeflash_output = _get_span_op("AI_CHAT") # 2.15μs -> 875ns (146% faster)
    codeflash_output = _get_span_op("Ai_Chat") # 925ns -> 408ns (127% faster)

def test_edge_whitespace():
    # Should default to OP.FUNCTION for whitespace-padded string
    codeflash_output = _get_span_op(" ai_chat") # 1.95μs -> 796ns (145% faster)
    codeflash_output = _get_span_op("ai_chat ") # 917ns -> 469ns (95.5% faster)
    codeflash_output = _get_span_op(" ai_chat ") # 836ns -> 377ns (122% faster)

def test_edge_similar_but_not_equal():
    # Should default to OP.FUNCTION for similar but not equal string
    codeflash_output = _get_span_op("ai_chat_") # 1.82μs -> 712ns (156% faster)
    codeflash_output = _get_span_op("ai_chat1") # 998ns -> 484ns (106% faster)



def test_large_scale_many_unknown_strings():
    # Test with many unknown string templates
    for i in range(1000):
        codeflash_output = _get_span_op(f"unknown_template_{i}") # 796μs -> 354μs (124% faster)



def test_large_scale_performance():
    # Performance test: Ensure function works quickly for 1000 calls
    import time
    start = time.time()
    for i in range(1000):
        _get_span_op("ai_chat") # 799μs -> 353μs (126% faster)
        _get_span_op("ai_agent") # 799μs -> 350μs (128% faster)
        _get_span_op("ai_tool") # 794μs -> 350μs (127% faster)
        _get_span_op(f"unknown_{i}") # 818μs -> 373μs (119% faster)
    duration = time.time() - start


#------------------------------------------------
from enum import Enum

# imports
import pytest  # used for our unit tests
from sentry_sdk.tracing_utils import _get_span_op


# --- Mocked sentry_sdk.consts for testing purposes ---
class OP(str, Enum):
    GEN_AI_CHAT = "gen.ai.chat"
    GEN_AI_INVOKE_AGENT = "gen.ai.invoke_agent"
    GEN_AI_EXECUTE_TOOL = "gen.ai.execute_tool"
    FUNCTION = "function"

class SPANTEMPLATE(str, Enum):
    AI_CHAT = "ai.chat"
    AI_AGENT = "ai.agent"
    AI_TOOL = "ai.tool"
from sentry_sdk.tracing_utils import _get_span_op

# ---------------------- UNIT TESTS ----------------------

# Basic Test Cases
def test_ai_chat_template_returns_gen_ai_chat():
    # Test with SPANTEMPLATE.AI_CHAT
    codeflash_output = _get_span_op(SPANTEMPLATE.AI_CHAT) # 3.54μs -> 1.54μs (130% faster)

def test_ai_agent_template_returns_gen_ai_invoke_agent():
    # Test with SPANTEMPLATE.AI_AGENT
    codeflash_output = _get_span_op(SPANTEMPLATE.AI_AGENT) # 2.24μs -> 956ns (134% faster)

def test_ai_tool_template_returns_gen_ai_execute_tool():
    # Test with SPANTEMPLATE.AI_TOOL
    codeflash_output = _get_span_op(SPANTEMPLATE.AI_TOOL) # 1.94μs -> 857ns (126% faster)

def test_string_equivalent_of_enum_keys():
    # Test with string values that match the enum values
    codeflash_output = _get_span_op("ai.chat") # 1.95μs -> 815ns (139% faster)
    codeflash_output = _get_span_op("ai.agent") # 939ns -> 458ns (105% faster)
    codeflash_output = _get_span_op("ai.tool") # 775ns -> 377ns (106% faster)

def test_unknown_template_returns_function():
    # Test with an unknown template value
    codeflash_output = _get_span_op("random.unknown") # 1.85μs -> 746ns (148% faster)

def test_none_template_returns_function():
    # Test with None as input
    codeflash_output = _get_span_op(None) # 2.01μs -> 802ns (150% faster)

def test_empty_string_template_returns_function():
    # Test with empty string as input
    codeflash_output = _get_span_op("") # 1.96μs -> 828ns (137% faster)

def test_integer_template_returns_function():
    # Test with integer as input
    codeflash_output = _get_span_op(123) # 1.99μs -> 845ns (135% faster)

def test_float_template_returns_function():
    # Test with float as input
    codeflash_output = _get_span_op(3.14) # 2.14μs -> 1.06μs (102% faster)

def test_bool_template_returns_function():
    # Test with boolean as input
    codeflash_output = _get_span_op(True) # 1.94μs -> 760ns (155% faster)
    codeflash_output = _get_span_op(False) # 950ns -> 494ns (92.3% faster)



def test_bytes_template_returns_function():
    # Test with bytes as input
    codeflash_output = _get_span_op(b"ai.chat") # 3.22μs -> 1.60μs (101% faster)

# Edge Test Cases
def test_template_with_whitespace_returns_function():
    # Test with whitespace in string
    codeflash_output = _get_span_op(" ai.chat ") # 2.20μs -> 870ns (152% faster)

def test_template_case_sensitivity_returns_function():
    # Test with different casing
    codeflash_output = _get_span_op("AI.CHAT") # 2.02μs -> 855ns (137% faster)
    codeflash_output = _get_span_op("Ai.Chat") # 1.00μs -> 413ns (143% faster)

def test_template_with_special_characters_returns_function():
    # Test with special characters
    codeflash_output = _get_span_op("ai.chat!") # 1.92μs -> 788ns (143% faster)
    codeflash_output = _get_span_op("ai.chat?") # 1.01μs -> 432ns (133% faster)

def test_template_with_long_string_returns_function():
    # Test with a very long string
    long_string = "a" * 1000
    codeflash_output = _get_span_op(long_string) # 1.78μs -> 741ns (141% faster)


def test_template_with_non_ascii_returns_function():
    # Test with non-ASCII characters
    codeflash_output = _get_span_op("ai.chât") # 3.21μs -> 1.54μs (109% faster)
    codeflash_output = _get_span_op("机器人") # 1.12μs -> 429ns (162% faster)

def test_template_with_tuple_returns_function():
    # Test with tuple as input
    codeflash_output = _get_span_op(("ai.chat",)) # 2.19μs -> 892ns (146% faster)

def test_template_with_frozenset_returns_function():
    # Test with frozenset as input
    codeflash_output = _get_span_op(frozenset(["ai.chat"])) # 1.94μs -> 980ns (98.4% faster)

def test_template_with_object_returns_function():
    # Test with a generic object
    class Dummy: pass
    codeflash_output = _get_span_op(Dummy()) # 1.97μs -> 862ns (128% faster)

# Large Scale Test Cases
def test_bulk_enum_templates_all_return_expected_ops():
    # Test with all valid enum templates in bulk
    templates = [SPANTEMPLATE.AI_CHAT, SPANTEMPLATE.AI_AGENT, SPANTEMPLATE.AI_TOOL]
    expected = [OP.GEN_AI_CHAT, OP.GEN_AI_INVOKE_AGENT, OP.GEN_AI_EXECUTE_TOOL]
    for t, e in zip(templates, expected):
        codeflash_output = _get_span_op(t) # 3.59μs -> 1.71μs (110% faster)

def test_bulk_invalid_templates_all_return_function():
    # Test with a large number of invalid templates
    invalid_templates = [f"invalid_{i}" for i in range(1000)]
    for t in invalid_templates:
        codeflash_output = _get_span_op(t) # 792μs -> 351μs (126% faster)

def test_bulk_mixed_templates():
    # Test with a mix of valid and invalid templates
    templates = [SPANTEMPLATE.AI_CHAT, "ai.chat", "invalid", SPANTEMPLATE.AI_AGENT, None, SPANTEMPLATE.AI_TOOL, 42]
    expected = [
        OP.GEN_AI_CHAT, OP.FUNCTION, OP.FUNCTION,
        OP.GEN_AI_INVOKE_AGENT, OP.FUNCTION, OP.GEN_AI_EXECUTE_TOOL, OP.FUNCTION
    ]
    for t, e in zip(templates, expected):
        codeflash_output = _get_span_op(t) # 7.16μs -> 3.08μs (132% faster)

def test_bulk_enum_and_string_equivalents():
    # Test with enums and their string equivalents in large scale
    templates = [SPANTEMPLATE.AI_CHAT, "ai.chat"] * 500
    expected = [OP.GEN_AI_CHAT, OP.FUNCTION] * 500
    for t, e in zip(templates, expected):
        codeflash_output = _get_span_op(t) # 772μs -> 333μs (131% faster)

def test_bulk_none_and_empty_string_templates():
    # Test with None and empty string in large scale
    templates = [None, ""] * 500
    for t in templates:
        codeflash_output = _get_span_op(t) # 778μs -> 327μs (138% faster)

def test_bulk_object_templates():
    # Test with many object instances
    class Dummy: pass
    templates = [Dummy() for _ in range(500)]
    for t in templates:
        codeflash_output = _get_span_op(t) # 380μs -> 161μs (135% faster)

def test_bulk_numeric_templates():
    # Test with many numeric values
    templates = list(range(1000))
    for t in templates:
        codeflash_output = _get_span_op(t) # 782μs -> 337μs (132% faster)

def test_bulk_boolean_templates():
    # Test with many boolean values
    templates = [True, False] * 500
    for t in templates:
        codeflash_output = _get_span_op(t) # 768μs -> 330μs (133% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-_get_span_op-mg9nsltp and push.