⚡️ Speed up function normalize_incoming_data by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for normalize_incoming_data in sentry_sdk/tracing_utils.py

⏱️ Runtime : 2.41 milliseconds → 2.23 milliseconds (best of 85 runs)

📝 Explanation and details

The optimized code achieves an 8% speedup through several micro-optimizations that reduce Python's attribute lookup overhead in the inner loop:

Key Optimizations:

1. Local variable caching: Pre-stores str.replace and str.lower as local variables (replace, lower), eliminating repeated attribute lookups on the str class during each iteration.

2. Constant optimization: Caches HTTP_PREFIX and its length (HTTP_PREFIX_LEN) to avoid recalculating len("HTTP_") and repeated string literal access.

3. Method call optimization: Uses the cached local functions directly (lower(replace(key, "_", "-"))) instead of chaining method calls on the key object.

Why it's faster: In Python, local variable lookups are significantly faster than attribute lookups. The original code performs key.replace("_", "-").lower() which requires two attribute lookups per iteration. The optimized version eliminates these lookups by using pre-cached local references.

Performance characteristics: The optimization shows mixed results in individual test cases (many single-key tests are actually slower due to setup overhead), but shines in large-scale scenarios. Tests with 1000+ keys show significant improvements (up to 52% faster in test_large_scale_many_keys), demonstrating that the optimization benefits scale with the number of iterations where the setup cost is amortized across many loop iterations.

This optimization is most beneficial for workloads processing many HTTP headers or similar key-value transformations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

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

# unit tests

# 1. Basic Test Cases

def test_basic_single_key_no_prefix():
    # Should lowercase and replace underscores with dashes
    input_data = {'My_KEY': 'value'}
    expected = {'my-key': 'value'}
    codeflash_output = normalize_incoming_data(input_data) # 2.45μs -> 2.98μs (17.8% slower)

def test_basic_multiple_keys_with_and_without_prefix():
    # Should handle both prefixed and non-prefixed keys
    input_data = {
        'HTTP_CONTENT_TYPE': 'application/json',
        'user_id': 123,
        'HTTP_X_CUSTOM_HEADER': 'abc'
    }
    expected = {
        'content-type': 'application/json',
        'user-id': 123,
        'x-custom-header': 'abc'
    }
    codeflash_output = normalize_incoming_data(input_data) # 3.23μs -> 3.98μs (19.0% slower)

def test_basic_empty_dict():
    # Should return empty dict for empty input
    input_data = {}
    expected = {}
    codeflash_output = normalize_incoming_data(input_data) # 893ns -> 1.38μs (35.4% slower)

def test_basic_key_with_multiple_underscores():
    # Should replace all underscores with dashes
    input_data = {'HTTP_X_SOME_LONG_HEADER_NAME': 'val'}
    expected = {'x-some-long-header-name': 'val'}
    codeflash_output = normalize_incoming_data(input_data) # 2.30μs -> 2.81μs (18.1% slower)

def test_basic_key_is_only_prefix():
    # Should handle key that is just the prefix
    input_data = {'HTTP_': 'val'}
    expected = {'': 'val'}
    codeflash_output = normalize_incoming_data(input_data) # 1.91μs -> 2.22μs (14.2% slower)

# 2. Edge Test Cases

def test_edge_key_is_empty_string():
    # Should handle empty key
    input_data = {'': 'empty'}
    expected = {'': 'empty'}
    codeflash_output = normalize_incoming_data(input_data) # 1.57μs -> 2.08μs (24.6% slower)

def test_edge_key_is_only_underscores():
    # Should handle keys with only underscores
    input_data = {'___': 'val'}
    expected = {'---': 'val'}
    codeflash_output = normalize_incoming_data(input_data) # 1.88μs -> 2.39μs (21.2% slower)

def test_edge_key_with_mixed_case_and_prefix():
    # Should lowercase and strip prefix regardless of case
    input_data = {'HTTP_My_MIXED_Case_KEY': 'v'}
    expected = {'my-mixed-case-key': 'v'}
    codeflash_output = normalize_incoming_data(input_data) # 2.26μs -> 2.61μs (13.4% slower)

def test_edge_key_with_leading_and_trailing_underscores():
    # Should replace all underscores, even at ends
    input_data = {'HTTP__LEAD__TRAIL__': 'v'}
    expected = {'-lead--trail--': 'v'}
    codeflash_output = normalize_incoming_data(input_data) # 2.14μs -> 2.65μs (19.3% slower)

def test_edge_key_with_no_underscores_or_prefix():
    # Should just lowercase
    input_data = {'SomeKey': 'v'}
    expected = {'somekey': 'v'}
    codeflash_output = normalize_incoming_data(input_data) # 1.67μs -> 2.08μs (19.7% slower)

def test_edge_key_with_only_http_prefix():
    # Should strip prefix and handle empty string
    input_data = {'HTTP_': 'v'}
    expected = {'': 'v'}
    codeflash_output = normalize_incoming_data(input_data) # 1.82μs -> 2.25μs (19.3% slower)

def test_edge_key_with_http_in_middle():
    # Should not strip unless at start
    input_data = {'X_HTTP_HEADER': 'v'}
    expected = {'x-http-header': 'v'}
    codeflash_output = normalize_incoming_data(input_data) # 1.86μs -> 2.30μs (18.9% slower)

def test_edge_key_with_non_string_key():
    # Should handle non-string keys (should not modify them)
    input_data = {123: 'num', None: 'none'}
    # These keys are not strings, so the function will fail if it tries to call .startswith or .replace on them.
    # Let's check for TypeError.
    with pytest.raises(AttributeError):
        normalize_incoming_data(input_data) # 1.99μs -> 2.56μs (22.2% slower)

def test_edge_key_with_special_characters():
    # Should only replace underscores, leave other chars
    input_data = {'HTTP_X$Y@Z_': 'v'}
    expected = {'x$y@z-': 'v'}
    codeflash_output = normalize_incoming_data(input_data) # 2.30μs -> 2.95μs (22.1% slower)

def test_edge_key_with_spaces():
    # Should replace underscores, leave spaces
    input_data = {'HTTP_X Y_Z': 'v'}
    expected = {'x y-z': 'v'}
    codeflash_output = normalize_incoming_data(input_data) # 1.99μs -> 2.63μs (24.4% slower)

def test_edge_value_is_none():
    # Should preserve None values
    input_data = {'HTTP_X_KEY': None}
    expected = {'x-key': None}
    codeflash_output = normalize_incoming_data(input_data) # 2.06μs -> 2.46μs (16.2% slower)

def test_edge_value_is_list():
    # Should preserve list values
    input_data = {'HTTP_X_KEY': [1,2,3]}
    expected = {'x-key': [1,2,3]}
    codeflash_output = normalize_incoming_data(input_data) # 1.89μs -> 2.48μs (23.6% slower)

def test_edge_value_is_dict():
    # Should preserve dict values
    input_data = {'HTTP_X_KEY': {'a': 1}}
    expected = {'x-key': {'a': 1}}
    codeflash_output = normalize_incoming_data(input_data) # 1.86μs -> 2.36μs (21.0% slower)

def test_edge_key_with_dash_and_underscore():
    # Should replace underscores but leave dashes
    input_data = {'HTTP_X-KEY_NAME': 'v'}
    expected = {'x-key-name': 'v'}
    codeflash_output = normalize_incoming_data(input_data) # 2.07μs -> 2.52μs (17.9% slower)

def test_edge_key_with_multiple_prefixes():
    # Only strip one HTTP_ prefix
    input_data = {'HTTP_HTTP_X_KEY': 'v'}
    expected = {'http-x-key': 'v'}
    codeflash_output = normalize_incoming_data(input_data) # 2.07μs -> 2.48μs (16.6% slower)

def test_edge_key_is_http_only():
    # Should not strip prefix unless it ends with _
    input_data = {'HTTP': 'v'}
    expected = {'http': 'v'}
    codeflash_output = normalize_incoming_data(input_data) # 1.59μs -> 2.05μs (22.7% slower)

# 3. Large Scale Test Cases

def test_large_scale_many_keys():
    # Should handle 1000 keys efficiently
    input_data = {f'HTTP_KEY_{i}': i for i in range(1000)}
    expected = {f'key-{i}': i for i in range(1000)}
    codeflash_output = normalize_incoming_data(input_data); result = codeflash_output # 402μs -> 389μs (3.39% faster)

def test_large_scale_long_key_names():
    # Should handle very long key names
    long_key = 'HTTP_' + 'A_'*500  # 500 underscores
    input_data = {long_key: 'long'}
    expected_key = 'a-'*500
    expected_key = expected_key[:-1]  # remove trailing dash
    expected = {expected_key: 'long'}
    codeflash_output = normalize_incoming_data(input_data); result = codeflash_output # 4.60μs -> 5.25μs (12.5% slower)

def test_large_scale_large_values():
    # Should handle large values
    input_data = {'HTTP_X_KEY': 'a'*1000}
    expected = {'x-key': 'a'*1000}
    codeflash_output = normalize_incoming_data(input_data) # 2.00μs -> 2.62μs (23.5% slower)

def test_large_scale_keys_with_varied_patterns():
    # Should handle a mix of patterns
    input_data = {}
    expected = {}
    for i in range(500):
        input_data[f'HTTP_KEY_{i}'] = i
        expected[f'key-{i}'] = i
    for i in range(500, 1000):
        input_data[f'X_KEY_{i}'] = i
        expected[f'x-key-{i}'] = i
    codeflash_output = normalize_incoming_data(input_data); result = codeflash_output # 351μs -> 351μs (0.165% faster)

def test_large_scale_values_are_lists():
    # Should handle keys with list values
    input_data = {f'HTTP_KEY_{i}': [i, i+1] for i in range(1000)}
    expected = {f'key-{i}': [i, i+1] for i in range(1000)}
    codeflash_output = normalize_incoming_data(input_data); result = codeflash_output # 398μs -> 387μs (2.88% faster)

def test_large_scale_empty_keys():
    # Should handle many empty keys
    input_data = {'': i for i in range(1000)}
    expected = {'': i for i in range(1000)}
    codeflash_output = normalize_incoming_data(input_data); result = codeflash_output # 1.82μs -> 2.26μs (19.7% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest  # used for our unit tests
from sentry_sdk.tracing_utils import normalize_incoming_data

# unit tests

# 1. BASIC TEST CASES

def test_basic_single_key():
    # Single key with no prefix or underscores
    inp = {"Content": "text"}
    out = {"content": "text"}
    codeflash_output = normalize_incoming_data(inp) # 1.76μs -> 2.12μs (17.1% slower)

def test_basic_multiple_keys():
    # Multiple keys, mixed underscores
    inp = {"User_Name": "alice", "Age": 30}
    out = {"user-name": "alice", "age": 30}
    codeflash_output = normalize_incoming_data(inp) # 2.38μs -> 2.77μs (13.9% slower)

def test_basic_http_prefix():
    # Key with HTTP_ prefix should be stripped
    inp = {"HTTP_ACCEPT": "application/json"}
    out = {"accept": "application/json"}
    codeflash_output = normalize_incoming_data(inp) # 1.96μs -> 2.41μs (18.7% slower)

def test_basic_http_and_underscore():
    # Key with HTTP_ and underscores
    inp = {"HTTP_X_CUSTOM_HEADER": "foo"}
    out = {"x-custom-header": "foo"}
    codeflash_output = normalize_incoming_data(inp) # 2.14μs -> 2.50μs (14.5% slower)

def test_basic_mix_of_cases():
    # Mixed case keys
    inp = {"HTTP_Content_Type": "json", "X_Request_ID": "123"}
    out = {"content-type": "json", "x-request-id": "123"}
    codeflash_output = normalize_incoming_data(inp) # 2.57μs -> 3.29μs (21.6% slower)

def test_basic_empty_dict():
    # Empty dict should return empty dict
    inp = {}
    out = {}
    codeflash_output = normalize_incoming_data(inp) # 865ns -> 1.42μs (39.0% slower)

# 2. EDGE TEST CASES

def test_edge_key_only_http_prefix():
    # Key is exactly "HTTP_"
    inp = {"HTTP_": "value"}
    out = {"": "value"}
    codeflash_output = normalize_incoming_data(inp) # 1.93μs -> 2.32μs (16.8% slower)

def test_edge_key_only_underscores():
    # Key is only underscores
    inp = {"___": "foo"}
    out = {"---": "foo"}
    codeflash_output = normalize_incoming_data(inp) # 1.85μs -> 2.29μs (19.2% slower)

def test_edge_key_with_multiple_http_prefixes():
    # Key starts with multiple HTTP_ prefixes
    inp = {"HTTP_HTTP_ACCEPT": "bar"}
    # Only the first HTTP_ is stripped
    out = {"http-accept": "bar"}
    codeflash_output = normalize_incoming_data(inp) # 2.06μs -> 2.51μs (18.0% slower)

def test_edge_key_with_leading_trailing_underscores():
    # Key with leading and trailing underscores
    inp = {"_HTTP_X_": "baz"}
    # Only "HTTP_" at the start is stripped, not "_HTTP_"
    out = {"-http-x-": "baz"}
    codeflash_output = normalize_incoming_data(inp) # 1.77μs -> 2.22μs (20.3% slower)

def test_edge_key_with_numbers_and_symbols():
    # Key with numbers and symbols
    inp = {"HTTP_X_123_ABC!": "val"}
    out = {"x-123-abc!": "val"}
    codeflash_output = normalize_incoming_data(inp) # 2.04μs -> 2.48μs (18.1% slower)

def test_edge_key_is_empty_string():
    # Key is empty string
    inp = {"": "empty"}
    out = {"": "empty"}
    codeflash_output = normalize_incoming_data(inp) # 1.55μs -> 1.97μs (21.4% slower)

def test_edge_value_is_none():
    # Value is None
    inp = {"HTTP_NULL": None}
    out = {"null": None}
    codeflash_output = normalize_incoming_data(inp) # 1.93μs -> 2.32μs (16.8% slower)

def test_edge_value_is_list_or_dict():
    # Value is a list or dict
    inp = {"HTTP_LIST": [1,2], "HTTP_DICT": {"a": 1}}
    out = {"list": [1,2], "dict": {"a": 1}}
    codeflash_output = normalize_incoming_data(inp) # 2.41μs -> 2.80μs (14.0% slower)

def test_edge_key_with_mixed_case_and_underscore():
    # Key with mixed case and underscores
    inp = {"HtTp_My_Key": "val"}
    out = {"http-my-key": "val"}
    codeflash_output = normalize_incoming_data(inp) # 1.89μs -> 2.30μs (18.0% slower)

def test_edge_key_with_spaces():
    # Key contains spaces
    inp = {"HTTP_X CUSTOM_HEADER": "foo"}
    out = {"x custom-header": "foo"}
    codeflash_output = normalize_incoming_data(inp) # 2.03μs -> 2.58μs (21.1% slower)

# 3. LARGE SCALE TEST CASES

def test_large_scale_many_keys():
    # Many keys, all with HTTP_ prefix and underscores
    inp = {f"HTTP_KEY_{i}_VAL": i for i in range(1000)}
    out = {f"key-{i}-val": i for i in range(1000)}
    codeflash_output = normalize_incoming_data(inp) # 414μs -> 272μs (52.2% faster)

def test_large_scale_long_keys():
    # Very long key names
    key = "HTTP_" + "_".join(["LONGKEY"]*100)
    inp = {key: "value"}
    out = {"longkey-"*99 + "longkey": "value"}
    codeflash_output = normalize_incoming_data(inp) # 3.69μs -> 4.41μs (16.5% slower)

def test_large_scale_mixed_keys():
    # Mix of keys, some with HTTP_, some without, some with underscores
    inp = {}
    out = {}
    for i in range(500):
        inp[f"HTTP_MIXED_KEY_{i}"] = i
        out[f"mixed-key-{i}"] = i
    for i in range(500):
        inp[f"plain_key_{i}"] = i+500
        out[f"plain-key-{i}"] = i+500
    codeflash_output = normalize_incoming_data(inp) # 371μs -> 344μs (7.91% faster)

def test_large_scale_all_edge_cases():
    # Large set of keys with edge cases (empty, only underscores, numbers, etc.)
    inp = {}
    out = {}
    for i in range(250):
        inp[f"HTTP_{'_'*i}"] = i
        out[f"{'-'*i}"] = i
    for i in range(250):
        inp[f"HTTP_{i}_KEY"] = i
        out[f"{i}-key"] = i
    for i in range(250):
        inp[f"HTTP_KEY_{i}_"] = i
        out[f"key-{i}-"] = i
    for i in range(250):
        inp["HTTP_"] = i  # This will overwrite previous values, final value will be 249
        out[""] = i
    codeflash_output = normalize_incoming_data(inp) # 386μs -> 375μs (2.89% faster)

# Additional edge: ensure function does not mutate input
def test_input_not_mutated():
    inp = {"HTTP_MY_KEY": "val"}
    inp_copy = inp.copy()
    normalize_incoming_data(inp) # 2.09μs -> 2.59μs (19.3% slower)

# Additional edge: test with non-string keys (should not change them)

To edit these changes git checkout codeflash/optimize-normalize_incoming_data-mg9n0ylf and push.