⚡️ Speed up function _get_safe_key by 14%

[codeflash-ai]

📄 14% (0.14x) speedup for _get_safe_key in sentry_sdk/integrations/redis/utils.py

⏱️ Runtime : 116 microseconds → 101 microseconds (best of 182 runs)

📝 Explanation and details

The optimized code achieves a 14% speedup through several key micro-optimizations that reduce redundant operations and leverage faster type checking:

Key Optimizations:

1. Single .lower() call: The original code called method_name.lower() in the condition, but the optimized version stores it once as method_l and reuses it, eliminating duplicate string operations.

2. Early returns: Added explicit return statements after finding keys, avoiding unnecessary condition checks. This is particularly effective for multi-key commands and args-based lookups.

3. Faster type checking: Replaced isinstance(v, (dict, list, tuple)) with direct type comparisons t is list or t is tuple or t is dict. The type() function with identity checks (is) is faster than isinstance() for exact type matching.

4. Optimized kwargs access: Changed "key" in kwargs + kwargs["key"] pattern to kwargs.get("key", None), reducing dictionary lookups from two to one.

5. Faster emptiness check: Replaced len(kwargs["key"]) > 0 with simple truthiness test if k:, which is faster for checking non-empty collections.

Performance Impact by Test Case:

• Largest gains (30-65% faster): kwargs-based operations, especially with tuples and None values
• Moderate gains (15-25% faster): args with collections (lists, tuples, dicts)
• Minimal impact: Multi-key commands and large-scale operations show smaller or sometimes slight regressions due to the additional variable assignments, but the overall benefit across typical usage patterns is positive

The optimizations are most effective for common Redis/Django caching scenarios involving single keys or small collections, where the reduced function call overhead and eliminated redundant operations provide meaningful performance improvements.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any, Optional

# imports
import pytest  # used for our unit tests
from sentry_sdk.integrations.redis.utils import _get_safe_key

# Simulate _MULTI_KEY_COMMANDS for testing purposes
_MULTI_KEY_COMMANDS = {
    "mget",
    "mset",
    "del",
    "unlink",
    "touch",
    "exists",
    "blpop",
    "brpop",
    "sdiff",
    "sinter",
    "smove",
    "sunion",
    "zinterstore",
    "zunionstore",
    "zinter",
    "zunion",
}
from sentry_sdk.integrations.redis.utils import _get_safe_key

# -------------------------------
# Basic Test Cases
# -------------------------------

def test_single_key_in_args():
    # Basic: Single key as first arg, non-multi-key command
    codeflash_output = _get_safe_key("get", ("mykey",), None) # 1.59μs -> 1.46μs (8.77% faster)

def test_multi_key_command_with_multiple_keys():
    # Basic: Multi-key command with multiple keys in args
    codeflash_output = _get_safe_key("mget", ("key1", "key2", "key3"), None) # 1.03μs -> 1.07μs (3.00% slower)

def test_args_first_element_is_list():
    # Basic: First arg is a list of keys
    codeflash_output = _get_safe_key("get_many", (["a", "b", "c"],), None) # 1.59μs -> 1.39μs (14.9% faster)

def test_args_first_element_is_tuple():
    # Basic: First arg is a tuple of keys
    codeflash_output = _get_safe_key("get_many", (("x", "y"),), None) # 1.75μs -> 1.29μs (34.9% faster)

def test_args_first_element_is_dict():
    # Basic: First arg is a dict of keys
    codeflash_output = _get_safe_key("set_many", ({"foo": 1, "bar": 2},), None) # 1.82μs -> 1.64μs (11.2% faster)

def test_kwargs_key_single_value():
    # Basic: Key provided in kwargs as a string
    codeflash_output = _get_safe_key("get", None, {"key": "single_key"}) # 1.14μs -> 850ns (34.5% faster)

def test_kwargs_key_list():
    # Basic: Key provided in kwargs as a list
    codeflash_output = _get_safe_key("get_many", None, {"key": ["k1", "k2"]}) # 1.21μs -> 944ns (27.6% faster)

def test_kwargs_key_tuple():
    # Basic: Key provided in kwargs as a tuple
    codeflash_output = _get_safe_key("get_many", None, {"key": ("alpha", "beta")}) # 1.30μs -> 943ns (38.2% faster)

# -------------------------------
# Edge Test Cases
# -------------------------------

def test_args_none_and_kwargs_none():
    # Edge: Both args and kwargs are None
    codeflash_output = _get_safe_key("get", None, None) # 480ns -> 442ns (8.60% faster)

def test_args_empty_tuple():
    # Edge: args is an empty tuple
    codeflash_output = _get_safe_key("get", (), None) # 1.12μs -> 1.16μs (3.03% slower)

def test_args_first_element_empty_list():
    # Edge: args first element is an empty list
    codeflash_output = _get_safe_key("get_many", ([],), None) # 1.60μs -> 1.35μs (18.3% faster)

def test_args_first_element_empty_tuple():
    # Edge: args first element is an empty tuple
    codeflash_output = _get_safe_key("get_many", ((),), None) # 1.74μs -> 1.16μs (49.7% faster)

def test_args_first_element_empty_dict():
    # Edge: args first element is an empty dict
    codeflash_output = _get_safe_key("set_many", ({},), None) # 1.87μs -> 1.62μs (15.2% faster)

def test_kwargs_key_empty_list():
    # Edge: kwargs["key"] is an empty list
    codeflash_output = _get_safe_key("get_many", None, {"key": []}) # 935ns -> 868ns (7.72% faster)

def test_kwargs_key_empty_tuple():
    # Edge: kwargs["key"] is an empty tuple
    codeflash_output = _get_safe_key("get_many", None, {"key": ()}) # 1.24μs -> 811ns (52.9% faster)

def test_kwargs_key_none():
    # Edge: kwargs["key"] is None
    codeflash_output = _get_safe_key("get", None, {"key": None}) # 946ns -> 613ns (54.3% faster)

def test_args_first_element_none():
    # Edge: args first element is None
    codeflash_output = _get_safe_key("get", (None,), None) # 1.68μs -> 1.42μs (18.1% faster)

def test_args_first_element_is_int():
    # Edge: args first element is an integer (not a key, but should be returned as tuple)
    codeflash_output = _get_safe_key("get", (12345,), None) # 1.54μs -> 1.40μs (10.1% faster)

def test_args_first_element_is_bytes():
    # Edge: args first element is bytes
    codeflash_output = _get_safe_key("get", (b"key_bytes",), None) # 1.60μs -> 1.30μs (23.1% faster)

def test_kwargs_key_is_int():
    # Edge: kwargs["key"] is an integer
    codeflash_output = _get_safe_key("get", None, {"key": 987}) # 1.14μs -> 901ns (26.9% faster)

def test_method_name_case_insensitivity():
    # Edge: method_name should be case-insensitive for multi-key commands
    codeflash_output = _get_safe_key("MGET", ("a", "b"), None) # 1.08μs -> 1.15μs (5.49% slower)
    codeflash_output = _get_safe_key("mGeT", ("x", "y"), None) # 461ns -> 458ns (0.655% faster)

def test_args_first_element_is_set():
    # Edge: args first element is a set (should not be treated as multi-key)
    # Sets are not handled, so should be wrapped as a single element tuple
    codeflash_output = _get_safe_key("get", ({"setkey"},), None) # 1.63μs -> 1.39μs (16.7% faster)

def test_kwargs_key_is_set():
    # Edge: kwargs["key"] is a set (should be wrapped as a single element tuple)
    codeflash_output = _get_safe_key("get", None, {"key": {"setkey"}}) # 1.21μs -> 892ns (35.7% faster)

def test_args_multi_key_command_with_empty_args():
    # Edge: multi-key command with empty args
    codeflash_output = _get_safe_key("mget", (), None) # 1.06μs -> 1.05μs (1.05% faster)

def test_args_multi_key_command_with_non_string_keys():
    # Edge: multi-key command with non-string keys
    codeflash_output = _get_safe_key("mget", (1, 2, 3), None) # 996ns -> 984ns (1.22% faster)

def test_args_multi_key_command_with_mixed_types():
    # Edge: multi-key command with mixed types
    codeflash_output = _get_safe_key("mget", ("a", 1, b"b", None), None) # 926ns -> 943ns (1.80% slower)

def test_kwargs_missing_key():
    # Edge: kwargs does not contain "key"
    codeflash_output = _get_safe_key("get", None, {"not_key": "value"}) # 538ns -> 577ns (6.76% slower)

def test_args_and_kwargs_both_provided():
    # Edge: args and kwargs both provided, args should take precedence
    codeflash_output = _get_safe_key("get", ("priority",), {"key": "should_not_be_used"}) # 1.71μs -> 1.43μs (19.5% faster)

def test_args_first_element_is_bool():
    # Edge: args first element is a bool
    codeflash_output = _get_safe_key("get", (True,), None) # 1.81μs -> 1.30μs (39.4% faster)

# -------------------------------
# Large Scale Test Cases
# -------------------------------

def test_large_multi_key_command():
    # Large: Multi-key command with 1000 keys
    keys = tuple(f"key{i}" for i in range(1000))
    codeflash_output = _get_safe_key("mget", keys, None) # 1.01μs -> 1.07μs (5.79% slower)

def test_large_args_first_element_list():
    # Large: args first element is a list of 1000 keys
    keys = [f"k{i}" for i in range(1000)]
    codeflash_output = _get_safe_key("get_many", (keys,), None) # 3.41μs -> 3.16μs (7.91% faster)

def test_large_args_first_element_dict():
    # Large: args first element is a dict with 1000 keys
    keys_dict = {f"key{i}": i for i in range(1000)}
    expected = tuple(keys_dict.keys())
    codeflash_output = _get_safe_key("set_many", (keys_dict,), None) # 5.42μs -> 5.91μs (8.39% slower)

def test_large_kwargs_key_list():
    # Large: kwargs["key"] is a list of 1000 keys
    keys = [f"k{i}" for i in range(1000)]
    codeflash_output = _get_safe_key("get_many", None, {"key": keys}) # 3.08μs -> 2.71μs (13.7% faster)

def test_large_kwargs_key_tuple():
    # Large: kwargs["key"] is a tuple of 1000 keys
    keys = tuple(f"k{i}" for i in range(1000))
    codeflash_output = _get_safe_key("get_many", None, {"key": keys}) # 1.50μs -> 913ns (64.4% faster)

def test_large_args_multi_key_command_with_mixed_types():
    # Large: multi-key command with mixed types and 1000 elements
    keys = tuple(str(i) if i % 2 == 0 else i for i in range(1000))
    codeflash_output = _get_safe_key("mget", keys, None) # 1.14μs -> 1.15μs (0.349% 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
from sentry_sdk.integrations.redis.utils import _get_safe_key

# Simulate _MULTI_KEY_COMMANDS as used in sentry_sdk
# For our tests, we need to define this set to match possible Redis multi-key commands
_MULTI_KEY_COMMANDS = {
    "mget", "mset", "del", "unlink", "sdiff", "sinter", "sunion", "zunion", "zinter", "zunionstore", "zinterstore"
}
from sentry_sdk.integrations.redis.utils import _get_safe_key

# -------------------------
# Basic Test Cases
# -------------------------

def test_single_key_in_args():
    # Basic: Single key passed as first arg
    codeflash_output = _get_safe_key("get", ("foo",), {}) # 1.75μs -> 1.51μs (15.9% faster)

def test_multi_key_command_with_multiple_keys():
    # Basic: Multi-key command with multiple keys in args
    codeflash_output = _get_safe_key("mget", ("foo", "bar", "baz"), {}) # 1.08μs -> 1.07μs (1.31% faster)

def test_args_with_list_of_keys():
    # Basic: First arg is a list of keys
    codeflash_output = _get_safe_key("get_many", (["foo", "bar"],), {}) # 1.61μs -> 1.40μs (15.3% faster)

def test_args_with_tuple_of_keys():
    # Basic: First arg is a tuple of keys
    codeflash_output = _get_safe_key("get_many", (("foo", "bar"),), {}) # 1.75μs -> 1.32μs (33.1% faster)

def test_args_with_dict_keys():
    # Basic: First arg is a dict (keys are the dict's keys)
    codeflash_output = _get_safe_key("set_many", ({"foo": 1, "bar": 2},), {}) # 1.84μs -> 1.59μs (15.3% faster)

def test_kwargs_with_single_key():
    # Basic: Single key in kwargs
    codeflash_output = _get_safe_key("get", None, {"key": "foo"}) # 1.11μs -> 885ns (26.0% faster)

def test_kwargs_with_list_of_keys():
    # Basic: List of keys in kwargs
    codeflash_output = _get_safe_key("get_many", None, {"key": ["foo", "bar"]}) # 1.19μs -> 961ns (23.6% faster)

def test_kwargs_with_tuple_of_keys():
    # Basic: Tuple of keys in kwargs
    codeflash_output = _get_safe_key("get_many", None, {"key": ("foo", "bar")}) # 1.18μs -> 993ns (18.8% faster)

# -------------------------
# Edge Test Cases
# -------------------------

def test_args_is_none_and_kwargs_is_none():
    # Edge: Both args and kwargs are None
    codeflash_output = _get_safe_key("get", None, None) # 408ns -> 460ns (11.3% slower)

def test_args_empty_tuple_and_kwargs_none():
    # Edge: args is empty tuple, kwargs is None
    codeflash_output = _get_safe_key("get", (), None) # 1.18μs -> 1.14μs (3.42% faster)

def test_args_with_first_arg_empty_list():
    # Edge: args with first arg as empty list
    codeflash_output = _get_safe_key("get_many", ([],), None) # 1.61μs -> 1.40μs (15.4% faster)

def test_args_with_first_arg_empty_tuple():
    # Edge: args with first arg as empty tuple
    codeflash_output = _get_safe_key("get_many", ((),), None) # 1.70μs -> 1.34μs (27.2% faster)

def test_args_with_first_arg_empty_dict():
    # Edge: args with first arg as empty dict
    codeflash_output = _get_safe_key("set_many", ({},), None) # 1.82μs -> 1.63μs (11.7% faster)

def test_kwargs_with_key_as_empty_list():
    # Edge: kwargs with key as empty list
    codeflash_output = _get_safe_key("get_many", None, {"key": []}) # 991ns -> 836ns (18.5% faster)

def test_kwargs_with_key_as_empty_tuple():
    # Edge: kwargs with key as empty tuple
    codeflash_output = _get_safe_key("get_many", None, {"key": ()}) # 1.22μs -> 915ns (33.3% faster)

def test_kwargs_with_key_as_none():
    # Edge: kwargs with key as None
    codeflash_output = _get_safe_key("get", None, {"key": None}) # 1.02μs -> 617ns (65.6% faster)

def test_args_with_non_string_first_arg():
    # Edge: args with first arg as int
    codeflash_output = _get_safe_key("get", (123,), None) # 1.71μs -> 1.48μs (16.1% faster)

def test_args_with_first_arg_as_set():
    # Edge: args with first arg as set (should not be treated as multi-key)
    codeflash_output = _get_safe_key("get_many", ({"foo", "bar"},), None) # 1.67μs -> 1.41μs (18.6% faster)

def test_kwargs_with_key_as_set():
    # Edge: kwargs with key as set (should not be treated as multi-key)
    codeflash_output = _get_safe_key("get_many", None, {"key": {"foo", "bar"}}) # 1.22μs -> 848ns (43.4% faster)

def test_args_with_first_arg_as_bool():
    # Edge: args with first arg as bool
    codeflash_output = _get_safe_key("get", (True,), None) # 1.86μs -> 1.33μs (40.5% faster)

def test_args_with_first_arg_as_none():
    # Edge: args with first arg as None
    codeflash_output = _get_safe_key("get", (None,), None) # 1.60μs -> 1.32μs (21.3% faster)

def test_kwargs_with_key_missing():
    # Edge: kwargs present but no 'key'
    codeflash_output = _get_safe_key("get", None, {"not_key": "foo"}) # 584ns -> 639ns (8.61% slower)

def test_method_name_case_insensitivity():
    # Edge: method_name case insensitivity for multi-key commands
    codeflash_output = _get_safe_key("MGET", ("foo", "bar"), None) # 1.13μs -> 1.11μs (1.81% faster)

def test_args_with_multiple_args_non_multi_key_command():
    # Edge: multiple args for non-multi-key command, should only use first arg
    codeflash_output = _get_safe_key("get", ("foo", "bar"), None) # 1.53μs -> 1.29μs (17.8% faster)

def test_args_with_first_arg_as_list_of_ints():
    # Edge: first arg is a list of ints
    codeflash_output = _get_safe_key("get_many", ([1, 2, 3],), None) # 1.60μs -> 1.36μs (18.1% faster)

def test_args_with_first_arg_as_dict_with_non_string_keys():
    # Edge: dict with non-string keys
    codeflash_output = _get_safe_key("set_many", ({1: "a", 2: "b"},), None) # 1.87μs -> 1.67μs (12.0% faster)

def test_kwargs_with_key_as_dict():
    # Edge: kwargs with key as dict (should not be treated as multi-key)
    codeflash_output = _get_safe_key("get_many", None, {"key": {"foo": "bar"}}) # 1.18μs -> 909ns (29.5% faster)

# -------------------------
# Large Scale Test Cases
# -------------------------

def test_multi_key_command_with_1000_keys():
    # Large scale: Multi-key command with 1000 keys
    keys = tuple(f"key{i}" for i in range(1000))
    codeflash_output = _get_safe_key("mget", keys, None); result = codeflash_output # 1.09μs -> 1.10μs (0.910% slower)

def test_args_with_first_arg_list_1000_keys():
    # Large scale: First arg is list of 1000 keys
    keys = [f"key{i}" for i in range(1000)]
    codeflash_output = _get_safe_key("get_many", (keys,), None); result = codeflash_output # 3.54μs -> 3.29μs (7.51% faster)

def test_args_with_first_arg_dict_1000_keys():
    # Large scale: First arg is dict with 1000 keys
    keys = {f"key{i}": i for i in range(1000)}
    codeflash_output = _get_safe_key("set_many", (keys,), None); result = codeflash_output # 5.92μs -> 6.13μs (3.34% slower)

def test_kwargs_with_key_list_1000_keys():
    # Large scale: kwargs with key as list of 1000 keys
    keys = [f"key{i}" for i in range(1000)]
    codeflash_output = _get_safe_key("get_many", None, {"key": keys}); result = codeflash_output # 3.12μs -> 2.62μs (19.0% faster)

def test_kwargs_with_key_tuple_1000_keys():
    # Large scale: kwargs with key as tuple of 1000 keys
    keys = tuple(f"key{i}" for i in range(1000))
    codeflash_output = _get_safe_key("get_many", None, {"key": keys}); result = codeflash_output # 1.31μs -> 963ns (36.6% faster)

def test_multi_key_command_with_mixed_types():
    # Large scale: Multi-key command with mixed types
    keys = ("foo", 123, None, True, "bar")
    codeflash_output = _get_safe_key("mget", keys, None); result = codeflash_output # 1.07μs -> 1.17μs (8.70% slower)

# -------------------------
# Mutation Testing Guards
# -------------------------

def test_mutation_guard_wrong_method_name():
    # If method_name is not in _MULTI_KEY_COMMANDS, should only use first arg
    codeflash_output = _get_safe_key("get", ("foo", "bar"), None) # 1.58μs -> 1.43μs (11.1% faster)
    # If method_name IS in _MULTI_KEY_COMMANDS, should use all args
    codeflash_output = _get_safe_key("mget", ("foo", "bar"), None) # 683ns -> 752ns (9.18% slower)

def test_mutation_guard_args_vs_kwargs_priority():
    # If args is present, kwargs should be ignored
    codeflash_output = _get_safe_key("get", ("foo",), {"key": "bar"}) # 1.50μs -> 1.28μs (17.5% faster)

def test_mutation_guard_empty_args_and_kwargs():
    # If both args and kwargs are empty, should return None
    codeflash_output = _get_safe_key("get", (), {}) # 1.06μs -> 1.16μs (8.03% slower)

def test_mutation_guard_none_key_in_kwargs():
    # If kwargs["key"] is None, should return None
    codeflash_output = _get_safe_key("get", None, {"key": None}) # 1.05μs -> 602ns (75.2% faster)

def test_mutation_guard_empty_key_in_kwargs():
    # If kwargs["key"] is empty list/tuple, should return None
    codeflash_output = _get_safe_key("get", None, {"key": []}) # 1.04μs -> 857ns (21.0% faster)
    codeflash_output = _get_safe_key("get", None, {"key": ()}) # 894ns -> 657ns (36.1% 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_safe_key-mg9laj0w and push.