⚡️ Speed up method StandardLoggingPayloadSetup._get_request_tags by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for StandardLoggingPayloadSetup._get_request_tags in litellm/litellm_core_utils/litellm_logging.py

⏱️ Runtime : 277 microseconds → 255 microseconds (best of 8 runs)

📝 Explanation and details

The optimized code achieves an 8% speedup through several key improvements:

1. Early Return Optimization

• Combines header validation checks: if not headers or not isinstance(headers, dict) eliminates redundant conditions and enables faster early returns when headers are missing or invalid
• Adds early return for missing user-agent values: if not user_agent: return None avoids unnecessary processing

2. Reduced Variable Assignments

• Removes unnecessary intermediate variables like user_agent_tags: Optional[List[str]] = None and directly initializes as user_agent_tags: List[str] = []
• Eliminates redundant user_agent_part: Optional[str] = None assignment by directly using the split result
• Removes the or [] fallback in extra_headers assignment since the check happens immediately after

3. List Comprehension Optimization

• Replaces the explicit loop in _get_extra_header_tags with a list comprehension using walrus operator: if (header_value := headers.get(header_name)). This eliminates the header_tags.append() function calls inside the loop and reduces overhead

4. Simplified String Operations

• Uses split("/", 1)[0] instead of split("/")[0] to limit splits to just one, slightly reducing work when processing user-agent strings

5. Optimized Conditionals

• Changes if user_agent_tags is not None to if user_agent_tags and if additional_header_tags is not None to if additional_header_tags, avoiding explicit None comparisons

The optimizations are most effective for:

• Empty/missing data scenarios (17-27% faster) due to early returns
• Large header processing (11-12% faster) due to list comprehension efficiency
• Basic cases (2-12% faster) from reduced variable assignments and simplified conditionals

The list comprehension optimization particularly shines in large-scale tests with many headers, while early returns provide the biggest gains when data is missing or invalid.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 16 Passed
🌀 Generated Regression Tests	✅ 24 Passed
⏪ Replay Tests	✅ 2 Passed
🔎 Concolic Coverage Tests	✅ 1 Passed
📊 Tests Coverage	100.0%

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_litellm/litellm_core_utils/test_litellm_logging.py::test_get_request_tags	5.90μs	5.91μs	-0.152%⚠️

🌀 Generated Regression Tests and Runtime

import sys

# imports
import pytest
from litellm.litellm_core_utils.litellm_logging import \
    StandardLoggingPayloadSetup


# Helper to patch litellm config for tests
def set_litellm_config(disable_user_agent=False, extra_headers=None):
    import litellm
    litellm.disable_add_user_agent_to_request_tags = disable_user_agent
    litellm.extra_spend_tag_headers = extra_headers if extra_headers is not None else []

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

# 1. Basic Test Cases

def test_basic_tags_only():
    """
    Basic: Only metadata tags, no headers
    """
    set_litellm_config()
    metadata = {"tags": ["foo", "bar"]}
    proxy_server_request = {}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.27μs -> 2.02μs (12.4% faster)

def test_basic_user_agent_header():
    """
    Basic: User-Agent header present, no metadata tags
    """
    set_litellm_config()
    metadata = {}
    proxy_server_request = {"headers": {"user-agent": "pytest/7.2.0"}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 3.69μs -> 3.51μs (5.28% faster)

def test_basic_tags_and_user_agent():
    """
    Basic: Both metadata tags and User-Agent header
    """
    set_litellm_config()
    metadata = {"tags": ["foo", "bar"]}
    proxy_server_request = {"headers": {"user-agent": "pytest/7.2.0"}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 3.85μs -> 3.77μs (2.12% faster)

def test_basic_extra_header_tags():
    """
    Basic: extra_spend_tag_headers present, header value present
    """
    set_litellm_config(extra_headers=["x-custom"])
    metadata = {}
    proxy_server_request = {"headers": {"x-custom": "value1"}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 3.50μs -> 3.80μs (7.90% slower)

def test_basic_tags_user_agent_and_extra_headers():
    """
    Basic: All sources present
    """
    set_litellm_config(extra_headers=["x-custom"])
    metadata = {"tags": ["foo"]}
    proxy_server_request = {"headers": {"user-agent": "pytest/7.2.0", "x-custom": "value1"}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 4.55μs -> 5.21μs (12.7% slower)

# 2. Edge Test Cases

def test_edge_empty_metadata_and_request():
    """
    Edge: Both metadata and proxy_server_request are empty
    """
    set_litellm_config()
    metadata = {}
    proxy_server_request = {}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.43μs -> 1.99μs (22.0% faster)

def test_edge_metadata_tags_not_list():
    """
    Edge: metadata['tags'] is not a list
    """
    set_litellm_config()
    metadata = {"tags": "notalist"}
    proxy_server_request = {}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.29μs -> 1.98μs (15.4% faster)

def test_edge_headers_not_dict():
    """
    Edge: proxy_server_request['headers'] is not a dict
    """
    set_litellm_config(extra_headers=["x-custom"])
    metadata = {}
    proxy_server_request = {"headers": "notadict"}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.51μs -> 2.35μs (6.67% faster)

def test_edge_user_agent_none():
    """
    Edge: User-Agent header is None
    """
    set_litellm_config()
    metadata = {}
    proxy_server_request = {"headers": {"user-agent": None}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.46μs -> 2.33μs (5.81% faster)

def test_edge_disable_user_agent_tag():
    """
    Edge: disable_add_user_agent_to_request_tags is True
    """
    set_litellm_config(disable_user_agent=True)
    metadata = {}
    proxy_server_request = {"headers": {"user-agent": "pytest/7.2.0"}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 1.79μs -> 1.78μs (1.01% faster)

def test_edge_extra_headers_empty_list():
    """
    Edge: extra_spend_tag_headers is empty list
    """
    set_litellm_config(extra_headers=[])
    metadata = {}
    proxy_server_request = {"headers": {"x-custom": "value1"}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.47μs -> 2.10μs (17.5% faster)

def test_edge_extra_headers_none():
    """
    Edge: extra_spend_tag_headers is None
    """
    set_litellm_config(extra_headers=None)
    metadata = {}
    proxy_server_request = {"headers": {"x-custom": "value1"}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.25μs -> 2.15μs (5.08% faster)

def test_edge_extra_header_not_present_in_request():
    """
    Edge: extra_spend_tag_headers set, but header not present in request
    """
    set_litellm_config(extra_headers=["x-missing"])
    metadata = {}
    proxy_server_request = {"headers": {"x-custom": "value1"}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.91μs -> 3.37μs (13.6% slower)

def test_edge_extra_header_present_but_value_none():
    """
    Edge: extra_spend_tag_headers set, header present but value is None
    """
    set_litellm_config(extra_headers=["x-custom"])
    metadata = {}
    proxy_server_request = {"headers": {"x-custom": None}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.84μs -> 3.18μs (10.7% slower)

def test_edge_user_agent_without_slash():
    """
    Edge: User-Agent header without a slash
    """
    set_litellm_config()
    metadata = {}
    proxy_server_request = {"headers": {"user-agent": "pytest"}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 3.10μs -> 2.89μs (7.31% faster)

def test_edge_headers_is_none():
    """
    Edge: proxy_server_request['headers'] is None
    """
    set_litellm_config()
    metadata = {}
    proxy_server_request = {"headers": None}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 1.89μs -> 1.89μs (0.106% faster)

def test_edge_metadata_is_none():
    """
    Edge: metadata is None
    """
    set_litellm_config()
    metadata = None
    proxy_server_request = {}
    # Should treat as empty dict
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata or {}, proxy_server_request); result = codeflash_output # 2.24μs -> 1.86μs (20.5% faster)

def test_edge_proxy_server_request_is_none():
    """
    Edge: proxy_server_request is None
    """
    set_litellm_config()
    metadata = {}
    proxy_server_request = None
    # Should treat as empty dict
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request or {}); result = codeflash_output # 2.34μs -> 1.83μs (27.7% faster)

def test_edge_metadata_tags_empty_list():
    """
    Edge: metadata['tags'] is an empty list
    """
    set_litellm_config()
    metadata = {"tags": []}
    proxy_server_request = {}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.27μs -> 1.96μs (15.3% faster)

# 3. Large Scale Test Cases

def test_large_many_metadata_tags():
    """
    Large: Many metadata tags
    """
    set_litellm_config()
    tags = [f"tag{i}" for i in range(1000)]
    metadata = {"tags": tags}
    proxy_server_request = {}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 2.50μs -> 2.21μs (13.2% faster)

def test_large_many_extra_headers():
    """
    Large: Many extra headers, all present in request
    """
    headers = {f"x-h{i}": f"v{i}" for i in range(1000)}
    set_litellm_config(extra_headers=[f"x-h{i}" for i in range(1000)])
    metadata = {}
    proxy_server_request = {"headers": headers}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 112μs -> 101μs (11.4% faster)
    expected = [f"x-h{i}: v{i}" for i in range(1000)]

def test_large_many_metadata_tags_and_headers():
    """
    Large: Many metadata tags and many extra headers, all present
    """
    tags = [f"tag{i}" for i in range(500)]
    headers = {f"x-h{i}": f"v{i}" for i in range(500)}
    set_litellm_config(extra_headers=[f"x-h{i}" for i in range(500)])
    metadata = {"tags": tags}
    proxy_server_request = {"headers": headers}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 56.9μs -> 50.7μs (12.3% faster)
    expected = tags + [f"x-h{i}: v{i}" for i in range(500)]

def test_large_user_agent_and_many_tags():
    """
    Large: User-Agent present, many tags
    """
    set_litellm_config()
    tags = [f"tag{i}" for i in range(500)]
    metadata = {"tags": tags}
    proxy_server_request = {"headers": {"user-agent": "pytest/7.2.0"}}
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 3.91μs -> 3.80μs (2.84% faster)
    expected = tags + ["User-Agent: pytest", "User-Agent: pytest/7.2.0"]

def test_large_all_sources():
    """
    Large: Many tags, user agent, many extra headers
    """
    tags = [f"tag{i}" for i in range(250)]
    extra_headers = [f"x-h{i}" for i in range(250)]
    headers = {**{f"x-h{i}": f"v{i}" for i in range(250)}, "user-agent": "pytest/7.2.0"}
    set_litellm_config(extra_headers=extra_headers)
    metadata = {"tags": tags}
    proxy_server_request = {"headers": headers}
    expected = (
        tags
        + ["User-Agent: pytest", "User-Agent: pytest/7.2.0"]
        + [f"x-h{i}: v{i}" for i in range(250)]
    )
    codeflash_output = StandardLoggingPayloadSetup._get_request_tags(metadata, proxy_server_request); result = codeflash_output # 34.3μs -> 32.6μs (5.13% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from litellm.litellm_core_utils.litellm_logging import StandardLoggingPayloadSetup

def test_StandardLoggingPayloadSetup__get_request_tags():
    StandardLoggingPayloadSetup._get_request_tags({}, {})

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_teststest_litellmresponseslitellm_completion_transformationtest_litellm_completion_responses___replay_test_0.py::test_litellm_litellm_core_utils_litellm_logging_StandardLoggingPayloadSetup__get_request_tags	6.43μs	5.73μs	12.1%✅

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_evt0erui/tmp1m7gsfnc/test_concolic_coverage.py::test_StandardLoggingPayloadSetup__get_request_tags	3.06μs	2.56μs	19.1%✅

To edit these changes git checkout codeflash/optimize-StandardLoggingPayloadSetup._get_request_tags-mhc1xka4 and push.