⚡️ Speed up function _compile_db_span_properties by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for _compile_db_span_properties in sentry_sdk/integrations/redis/modules/queries.py

⏱️ Runtime : 837 microseconds → 791 microseconds (best of 244 runs)

📝 Explanation and details

The optimized code achieves a 5% speedup through three key optimizations:

1. Eliminated expensive context manager overhead
The original code uses with capture_internal_exceptions(): which creates unnecessary overhead (10.4% of total time per profiler). The optimized version replaces this with a simple try/except, only falling back to command_name on the rare exception case - same behavior, but ~93% faster context handling.

2. Removed redundant variable assignment
The original code unnecessarily assigns description = command_name then immediately overwrites it. The optimized version eliminates this redundant assignment since _get_safe_command() rarely fails.

3. Optimized truncation logic

• Caches max_data_size to avoid repeated attribute access
• Only computes len(description) when truncation might be needed
• Uses hardcoded - 3 instead of len("...") calculation
• Skips truncation checks entirely when max_data_size is falsy

Performance characteristics by test type:

• Simple commands (no args/single arg): 22-39% faster due to context manager elimination
• Multiple args: 8-15% faster from combined optimizations
• Truncation cases: 5-36% faster from optimized length checks
• Large scale tests: 3-9% faster, with some edge cases showing minor regression due to changed control flow

The optimizations are most effective for simple Redis commands and cases where truncation isn't needed, which represent the majority of real-world usage patterns.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from sentry_sdk.integrations.redis.modules.queries import \
    _compile_db_span_properties


# Constants and dummy helpers for testing
class OP:
    DB_REDIS = "db.redis"
_MAX_NUM_ARGS = 5
def should_send_default_pii():
    # For testing, we can toggle this in tests
    return should_send_default_pii.flag
should_send_default_pii.flag = True

# Dummy RedisIntegration for testing
class RedisIntegration:
    def __init__(self, max_data_size=None):
        self.max_data_size = max_data_size
from sentry_sdk.integrations.redis.modules.queries import \
    _compile_db_span_properties

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

# Basic Test Cases

def test_basic_single_arg():
    """Test a simple command with a single argument."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "GET", ("mykey",)); result = codeflash_output # 3.64μs -> 2.96μs (22.9% faster)

def test_basic_multiple_args():
    """Test a command with several arguments."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "SET", ("mykey", "myvalue")); result = codeflash_output # 8.39μs -> 7.50μs (11.9% faster)

def test_basic_no_args():
    """Test a command with no arguments."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "PING", ()); result = codeflash_output # 2.65μs -> 1.90μs (39.4% faster)

def test_basic_sensitive_command():
    """Test a command that is considered sensitive."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "AUTH", ("user", "pass")); result = codeflash_output # 3.87μs -> 3.25μs (19.1% faster)

def test_basic_pii_disabled(monkeypatch):
    """Test that non-key args are filtered when PII is disabled."""
    integration = RedisIntegration()
    should_send_default_pii.flag = False
    codeflash_output = _compile_db_span_properties(integration, "SET", ("mykey", "myvalue")); result = codeflash_output # 8.89μs -> 8.79μs (1.18% faster)
    should_send_default_pii.flag = True  # reset

# Edge Test Cases

def test_edge_max_args():
    """Test that only up to _MAX_NUM_ARGS are processed."""
    integration = RedisIntegration()
    args = tuple(f"arg{i}" for i in range(_MAX_NUM_ARGS + 2))  # 7 args, but only 6 processed (0..5)
    codeflash_output = _compile_db_span_properties(integration, "MSET", args); result = codeflash_output # 19.6μs -> 19.7μs (0.539% slower)
    # Only up to _MAX_NUM_ARGS+1 arguments should be present in description
    desc_parts = result["description"].split(" ")

def test_edge_empty_command():
    """Test empty command name."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "", ("foo",)); result = codeflash_output # 3.92μs -> 3.07μs (27.7% faster)

def test_edge_empty_args():
    """Test command with empty tuple as args."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "INFO", ()); result = codeflash_output # 2.61μs -> 1.91μs (36.6% faster)

def test_edge_truncation():
    """Test that description is truncated when exceeding max_data_size."""
    integration = RedisIntegration(max_data_size=20)
    codeflash_output = _compile_db_span_properties(integration, "SET", ("verylongkeyname", "verylongvaluename")); result = codeflash_output # 10.2μs -> 9.59μs (5.97% faster)

def test_edge_truncation_exact():
    """Test that truncation works exactly at the boundary."""
    integration = RedisIntegration(max_data_size=10)
    codeflash_output = _compile_db_span_properties(integration, "PING", ("x"*10,)); result = codeflash_output # 4.90μs -> 4.01μs (22.3% faster)

def test_edge_sensitive_command_lowercase():
    """Test that sensitive command detection is case-insensitive."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "auth", ("user", "pass")); result = codeflash_output # 4.22μs -> 3.35μs (25.9% faster)

def test_edge_nonstring_args():
    """Test that non-string arguments are handled safely."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "SET", (123, {"a": 1})); result = codeflash_output # 9.38μs -> 8.56μs (9.62% faster)

def test_edge_args_with_special_chars():
    """Test that arguments with special characters are handled."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "SET", ("my key", "my\nvalue")); result = codeflash_output # 8.95μs -> 7.84μs (14.3% faster)

def test_edge_args_with_none():
    """Test that None arguments are handled."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "SET", (None, "val")); result = codeflash_output # 8.35μs -> 7.29μs (14.5% faster)

def test_edge_args_with_empty_string():
    """Test that empty string arguments are handled."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "SET", ("", "")); result = codeflash_output # 8.62μs -> 7.52μs (14.8% faster)

# Large Scale Test Cases

def test_large_many_args():
    """Test with a large number of arguments (up to _MAX_NUM_ARGS)."""
    integration = RedisIntegration()
    args = tuple(f"key{i}" for i in range(_MAX_NUM_ARGS + 1))
    codeflash_output = _compile_db_span_properties(integration, "DEL", args); result = codeflash_output # 17.1μs -> 19.5μs (12.4% slower)
    # Should include all args up to _MAX_NUM_ARGS+1
    for i in range(_MAX_NUM_ARGS + 1):
        pass

def test_large_long_strings():
    """Test with very long string arguments."""
    integration = RedisIntegration()
    long_str = "x" * 500
    codeflash_output = _compile_db_span_properties(integration, "SET", (long_str, long_str)); result = codeflash_output # 9.64μs -> 9.04μs (6.67% faster)

def test_large_truncation_with_many_args():
    """Test truncation with many arguments and small max_data_size."""
    integration = RedisIntegration(max_data_size=30)
    args = tuple("x"*10 for _ in range(_MAX_NUM_ARGS + 1))
    codeflash_output = _compile_db_span_properties(integration, "MSET", args); result = codeflash_output # 18.6μs -> 18.2μs (2.55% faster)

def test_large_sensitive_command_with_many_args():
    """Test sensitive command with many arguments."""
    integration = RedisIntegration()
    args = tuple(f"secret{i}" for i in range(10))
    codeflash_output = _compile_db_span_properties(integration, "CONFIG", args); result = codeflash_output # 25.8μs -> 25.4μs (1.80% faster)

def test_large_many_commands(monkeypatch):
    """Test many different commands in a loop."""
    integration = RedisIntegration()
    for i in range(50):
        cmd = f"CMD{i}"
        args = (f"key{i}", f"value{i}")
        codeflash_output = _compile_db_span_properties(integration, cmd, args); result = codeflash_output # 177μs -> 166μs (6.92% faster)

def test_large_args_with_various_types():
    """Test with a wide variety of argument types."""
    integration = RedisIntegration()
    args = (
        42,
        3.14,
        None,
        True,
        [1, 2, 3],
        {"a": "b"},
        (1, 2),
        set([1, 2]),
        b"bytes",
    )
    codeflash_output = _compile_db_span_properties(integration, "SET", args); result = codeflash_output # 23.8μs -> 22.8μs (4.41% faster)
    for arg in args[:_MAX_NUM_ARGS+1]:
        pass

def test_large_truncation_boundary():
    """Test truncation at the exact boundary of max_data_size."""
    integration = RedisIntegration(max_data_size=7)
    # "PING 'a'" is 8 chars, should be truncated to 7 with "..."
    codeflash_output = _compile_db_span_properties(integration, "PING", ("a",)); result = codeflash_output # 4.55μs -> 3.92μs (16.3% faster)

def test_large_args_with_unicode():
    """Test arguments with unicode characters."""
    integration = RedisIntegration()
    args = ("ключ", "значение", "🚀")
    codeflash_output = _compile_db_span_properties(integration, "SET", args); result = codeflash_output # 11.5μs -> 10.7μs (6.99% faster)
    for arg in args:
        pass

def test_large_args_with_large_tuple():
    """Test with the largest allowed tuple size."""
    integration = RedisIntegration()
    args = tuple(str(i) for i in range(999))
    codeflash_output = _compile_db_span_properties(integration, "MSET", args); result = codeflash_output # 28.8μs -> 27.1μs (6.19% faster)
    # Only up to _MAX_NUM_ARGS+1 args should be in the description
    desc_parts = result["description"].split(" ")
# 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.integrations.redis.modules.queries import \
    _compile_db_span_properties

# Constants and dummy functions/classes for testing
OP = SimpleNamespace(DB_REDIS="db.redis")
_MAX_NUM_ARGS = 10

# Dummy RedisIntegration class for testing
class RedisIntegration:
    def __init__(self, max_data_size=None):
        self.max_data_size = max_data_size
from sentry_sdk.integrations.redis.modules.queries import \
    _compile_db_span_properties

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

# Basic Test Cases

def test_basic_single_arg():
    """Test a simple command with a single argument."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "GET", ("mykey",)); result = codeflash_output # 4.56μs -> 3.55μs (28.5% faster)

def test_basic_multiple_args():
    """Test a command with multiple arguments."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "SET", ("mykey", "myvalue")); result = codeflash_output # 9.41μs -> 8.68μs (8.48% faster)

def test_basic_no_args():
    """Test a command with no arguments."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "PING", ()); result = codeflash_output # 2.67μs -> 1.97μs (35.3% faster)

def test_basic_case_insensitivity():
    """Test that command name is case-insensitive for sensitive commands."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "Set", ("key", "val")); result = codeflash_output # 9.01μs -> 8.14μs (10.7% faster)


def test_edge_max_data_size_truncation():
    """Test truncation when description exceeds max_data_size."""
    integration = RedisIntegration(max_data_size=15)
    codeflash_output = _compile_db_span_properties(integration, "GET", ("averylongkeyname",)); result = codeflash_output # 6.68μs -> 4.89μs (36.6% faster)

def test_edge_max_data_size_exact():
    """Test when description length is exactly max_data_size, no truncation."""
    integration = RedisIntegration(max_data_size=16)
    # "GET 'shortkey'" is 13 chars, so no truncation
    codeflash_output = _compile_db_span_properties(integration, "GET", ("shortkey",)); result = codeflash_output # 4.49μs -> 3.66μs (22.8% faster)

def test_edge_max_data_size_none():
    """Test max_data_size=None disables truncation."""
    integration = RedisIntegration(max_data_size=None)
    codeflash_output = _compile_db_span_properties(integration, "GET", ("averylongkeyname",)); result = codeflash_output # 4.12μs -> 3.36μs (22.7% faster)

def test_edge_empty_command_name():
    """Test empty command name."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "", ("key",)); result = codeflash_output # 3.93μs -> 3.29μs (19.4% faster)

def test_edge_empty_args():
    """Test empty args tuple."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "GET", ()); result = codeflash_output # 2.74μs -> 1.91μs (43.6% faster)

def test_edge_too_many_args():
    """Test args exceeding _MAX_NUM_ARGS."""
    integration = RedisIntegration()
    args = tuple(f"arg{i}" for i in range(_MAX_NUM_ARGS + 5))
    codeflash_output = _compile_db_span_properties(integration, "GET", args); result = codeflash_output # 30.6μs -> 34.0μs (9.99% slower)
    # Only up to _MAX_NUM_ARGS + 1 (first arg is key) should be present
    expected = "GET " + " ".join([repr(args[0])] + [repr(args[i]) for i in range(1, _MAX_NUM_ARGS + 1)])

def test_edge_sensitive_command_with_many_args():
    """Sensitive command with many args should still redact."""
    integration = RedisIntegration()
    args = tuple(f"val{i}" for i in range(20))
    codeflash_output = _compile_db_span_properties(integration, "SET", args); result = codeflash_output # 29.0μs -> 31.8μs (8.89% slower)

def test_edge_non_string_args():
    """Test non-string arguments (int, float, None, bool)."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "GET", (123, 4.5, None, True)); result = codeflash_output # 14.3μs -> 12.3μs (15.5% faster)

def test_edge_command_name_with_spaces():
    """Test command name with spaces."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "GET VALUE", ("key",)); result = codeflash_output # 3.85μs -> 3.23μs (19.1% faster)

def test_edge_args_with_special_characters():
    """Test args containing special characters."""
    integration = RedisIntegration()
    codeflash_output = _compile_db_span_properties(integration, "GET", ("key\n", "val\t", "Ω")); result = codeflash_output # 11.7μs -> 10.5μs (11.5% faster)

# Large Scale Test Cases

def test_large_many_args():
    """Test with a large number of arguments."""
    integration = RedisIntegration()
    args = tuple(f"val{i}" for i in range(1000))  # Only up to _MAX_NUM_ARGS handled
    codeflash_output = _compile_db_span_properties(integration, "GET", args); result = codeflash_output # 28.8μs -> 27.7μs (3.84% faster)
    # Only up to _MAX_NUM_ARGS + 1 args should be shown
    parts = result["description"].split(" ")

def test_large_long_command_name():
    """Test with a very long command name."""
    integration = RedisIntegration()
    long_command = "X" * 500
    codeflash_output = _compile_db_span_properties(integration, long_command, ("key",)); result = codeflash_output # 4.56μs -> 3.92μs (16.4% faster)

def test_large_max_data_size_truncation():
    """Test truncation on large description."""
    integration = RedisIntegration(max_data_size=50)
    args = tuple("val" + str(i) for i in range(20))
    codeflash_output = _compile_db_span_properties(integration, "GET", args); result = codeflash_output # 28.7μs -> 30.8μs (6.86% slower)

def test_large_sensitive_command_many_args():
    """Test sensitive command with many arguments, all redacted."""
    integration = RedisIntegration()
    args = tuple("val" + str(i) for i in range(100))
    codeflash_output = _compile_db_span_properties(integration, "SET", args); result = codeflash_output # 30.1μs -> 30.5μs (1.43% slower)

def test_large_many_commands():
    """Test multiple calls to the function with different commands."""
    integration = RedisIntegration()
    for i in range(50):
        cmd = f"CMD{i}"
        args = (f"key{i}", f"val{i}")
        codeflash_output = _compile_db_span_properties(integration, cmd, args); result = codeflash_output # 176μs -> 162μs (8.90% faster)
        # Should be cmd + repr(key) + repr(val)
        expected = f"{cmd} '{args[0]}' '{args[1]}'"

def test_large_args_with_large_strings():
    """Test args with very large strings."""
    integration = RedisIntegration()
    large_str = "A" * 500
    codeflash_output = _compile_db_span_properties(integration, "GET", (large_str,)); result = codeflash_output # 5.36μs -> 4.43μs (20.9% 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-_compile_db_span_properties-mg9vuwol and push.