⚡️ Speed up method JiraDataSource.get_dashboard_item_property_keys by 29%

[codeflash-ai]

📄 29% (0.29x) speedup for JiraDataSource.get_dashboard_item_property_keys in backend/python/app/sources/external/jira/jira.py

⏱️ Runtime : 2.56 milliseconds → 1.98 milliseconds (best of 243 runs)

📝 Explanation and details

The optimized code achieves a 28% speedup and 10% throughput improvement through two key optimizations:

1. Conditional String Conversion in _as_str_dict
The original code unconditionally converted all keys and values to strings:

return {str(k): _serialize_value(v) for k, v in d.items()}

The optimized version only performs conversion when necessary:

return {str(k) if not isinstance(k, str) else k: _serialize_value(v) if not isinstance(v, str) else v for k, v in d.items()}

This eliminates redundant str() calls and _serialize_value() calls when keys/values are already strings. The line profiler shows _as_str_dict time reduced from 3.04ms to 1.67ms (45% improvement), which is significant since this function is called 3 times per request (for headers, path_params, and query_params).

2. Optimized Headers Assignment
Changed from:

_headers: Dict[str, Any] = dict(headers or {})

to:

_headers: Dict[str, Any] = headers if headers is not None else {}

This avoids creating an unnecessary dictionary copy when headers is not None, reducing object allocation overhead.

3. Client Caching Optimization
In HTTPClient.execute(), the optimization caches the client instance:

client = self.client
if client is None:
    client = await self._ensure_client()

This avoids repeatedly calling _ensure_client() for subsequent requests on the same HTTPClient instance.

Performance Impact
These micro-optimizations are particularly effective for:

• High-volume scenarios: The throughput tests show consistent improvements across small (5 requests), medium (25-50 requests), and high-volume (100 requests) workloads
• Repeated API calls: Since JIRA integrations typically make many property key requests, the per-call savings compound significantly
• String-heavy workloads: Most HTTP headers and path parameters are already strings, making the conditional conversion highly effective

The optimizations maintain full API compatibility while reducing CPU overhead from unnecessary object creation and string conversions.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import asyncio  # used to run async functions

import pytest  # used for our unit tests
from app.sources.external.jira.jira import JiraDataSource


# ---- Minimal stubs for dependencies ----
class HTTPResponse:
    """Stub for HTTPResponse, mimics a real HTTP response object."""
    def __init__(self, data):
        self.data = data

    def json(self):
        return self.data

class HTTPRequest:
    """Stub for HTTPRequest, mimics a real HTTP request object."""
    def __init__(self, method, url, headers, path_params, query_params, body):
        self.method = method
        self.url = url
        self.headers = headers
        self.path_params = path_params
        self.query_params = query_params
        self.body = body

# ---- Minimal stub for JiraClient and its client ----
class DummyJiraRESTClient:
    """Stub for JiraRESTClientViaApiKey, mimics a real JIRA REST client."""
    def __init__(self, base_url):
        self.base_url = base_url

    def get_base_url(self):
        return self.base_url

    async def execute(self, request: HTTPRequest):
        # Simulate a successful response for known dashboard/item, error otherwise
        if "fail" in request.url:
            raise RuntimeError("Simulated HTTP failure")
        # Simulate property keys response
        return HTTPResponse({
            "keys": ["propA", "propB"],
            "dashboardId": request.path_params.get("dashboardId"),
            "itemId": request.path_params.get("itemId"),
            "headers": request.headers,
            "url": request.url,
        })

class DummyJiraClient:
    def __init__(self, client):
        self.client = client

    def get_client(self):
        return self.client
from app.sources.external.jira.jira import JiraDataSource

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

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_basic_success():
    """Test: Basic async call returns expected HTTPResponse for valid dashboard/item."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    resp = await ds.get_dashboard_item_property_keys("DASH-1", "ITEM-1")
    data = resp.json()

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_basic_headers():
    """Test: Headers are passed through and serialized correctly."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    headers = {"X-Test": "abc", "X-Num": 123}
    resp = await ds.get_dashboard_item_property_keys("DASH-2", "ITEM-2", headers)
    data = resp.json()

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_basic_async_behavior():
    """Test: Awaiting the coroutine returns the correct result."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    codeflash_output = ds.get_dashboard_item_property_keys("DASH-3", "ITEM-3"); coro = codeflash_output
    # Await the coroutine object
    resp = await coro
    data = resp.json()

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

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_invalid_client_none():
    """Test: Raises ValueError if client is None at construction."""
    class BadClient:
        def get_client(self):
            return None
    with pytest.raises(ValueError, match="HTTP client is not initialized"):
        JiraDataSource(BadClient())

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_invalid_client_missing_base_url():
    """Test: Raises ValueError if client lacks get_base_url."""
    class BadRESTClient:
        pass
    class BadClient:
        def get_client(self):
            return BadRESTClient()
    with pytest.raises(ValueError, match="HTTP client does not have get_base_url method"):
        JiraDataSource(BadClient())

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_client_execute_exception():
    """Test: If client.execute raises, exception bubbles up."""
    class FailingRESTClient(DummyJiraRESTClient):
        async def execute(self, request):
            raise RuntimeError("Simulated HTTP failure")
    client = DummyJiraClient(FailingRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    with pytest.raises(RuntimeError, match="Simulated HTTP failure"):
        await ds.get_dashboard_item_property_keys("fail-dash", "fail-item")

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_concurrent_execution():
    """Test: Multiple async calls concurrently return correct results."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    coros = [
        ds.get_dashboard_item_property_keys(f"DASH-{i}", f"ITEM-{i}")
        for i in range(5)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        data = resp.json()

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_empty_headers():
    """Test: Passing empty headers dict works and serializes as expected."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    resp = await ds.get_dashboard_item_property_keys("DASH-4", "ITEM-4", {})
    data = resp.json()

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_edge_case_special_chars():
    """Test: Dashboard/item IDs with special chars are handled correctly."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    resp = await ds.get_dashboard_item_property_keys("DASH/5", "ITEM?5")
    data = resp.json()

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

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_large_scale_concurrent():
    """Test: Many concurrent calls (up to 50) succeed and return correct results."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    count = 50
    coros = [
        ds.get_dashboard_item_property_keys(f"DASH-{i}", f"ITEM-{i}")
        for i in range(count)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        data = resp.json()

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_large_headers():
    """Test: Large number of headers are serialized correctly."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    headers = {f"X-Key-{i}": i for i in range(100)}
    resp = await ds.get_dashboard_item_property_keys("DASH-LARGE", "ITEM-LARGE", headers)
    data = resp.json()
    for i in range(100):
        pass

# ---- Throughput Test Cases ----

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_throughput_small_load():
    """Throughput: Small load, 10 concurrent requests complete quickly."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    coros = [
        ds.get_dashboard_item_property_keys(f"DASH-T-{i}", f"ITEM-T-{i}")
        for i in range(10)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        data = resp.json()

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_throughput_medium_load():
    """Throughput: Medium load, 50 concurrent requests complete quickly."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    coros = [
        ds.get_dashboard_item_property_keys(f"DASH-M-{i}", f"ITEM-M-{i}")
        for i in range(50)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        data = resp.json()

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_throughput_high_volume():
    """Throughput: High volume, 100 concurrent requests complete quickly."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    coros = [
        ds.get_dashboard_item_property_keys(f"DASH-H-{i}", f"ITEM-H-{i}")
        for i in range(100)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        data = resp.json()

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_throughput_sustained_pattern():
    """Throughput: Sustained execution pattern, repeated calls in succession."""
    client = DummyJiraClient(DummyJiraRESTClient("https://jira.example.com"))
    ds = JiraDataSource(client)
    for i in range(20):
        resp = await ds.get_dashboard_item_property_keys(f"DASH-S-{i}", f"ITEM-S-{i}")
        data = resp.json()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import asyncio  # used to run async functions
from typing import Any, Dict, Optional

import pytest  # used for our unit tests
from app.sources.external.jira.jira import JiraDataSource

# --- Minimal stubs for dependencies ---

class HTTPRequest:
    def __init__(self, method, url, headers, path_params, query_params, body):
        self.method = method
        self.url = url
        self.headers = headers
        self.path_params = path_params
        self.query_params = query_params
        self.body = body

class HTTPResponse:
    def __init__(self, content: Any, status_code: int = 200):
        self.content = content
        self.status_code = status_code

class DummyAsyncClient:
    """Minimal dummy async client for testing."""
    def __init__(self, base_url: str, execute_result: Any = None, raise_on_execute: Optional[Exception] = None):
        self._base_url = base_url
        self._execute_result = execute_result
        self._raise_on_execute = raise_on_execute
        self.last_request = None

    def get_base_url(self):
        return self._base_url

    async def execute(self, req):
        self.last_request = req
        if self._raise_on_execute:
            raise self._raise_on_execute
        # Simulate a real HTTPResponse
        return HTTPResponse(self._execute_result if self._execute_result is not None else {"ok": True}, status_code=200)

class JiraClient:
    def __init__(self, client):
        self.client = client

    def get_client(self):
        return self.client
from app.sources.external.jira.jira import JiraDataSource

# ------------------- TESTS -------------------

# 1. Basic Test Cases

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_basic_success():
    """Test basic successful async call returns expected HTTPResponse."""
    dummy_client = DummyAsyncClient("https://jira.example.com", execute_result={"keys": ["k1", "k2"]})
    ds = JiraDataSource(JiraClient(dummy_client))
    result = await ds.get_dashboard_item_property_keys("dash123", "item456")

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_basic_headers():
    """Test that custom headers are passed and stringified."""
    dummy_client = DummyAsyncClient("https://jira.example.com")
    ds = JiraDataSource(JiraClient(dummy_client))
    headers = {"X-Test": "abc", "Num": 123}
    await ds.get_dashboard_item_property_keys("d1", "i2", headers=headers)

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_url_formatting():
    """Test that URL is formatted correctly with path params."""
    dummy_client = DummyAsyncClient("https://jira.example.com")
    ds = JiraDataSource(JiraClient(dummy_client))
    await ds.get_dashboard_item_property_keys("DASH", "ITM")
    # URL should be formatted with dashboardId and itemId
    expected_url = "https://jira.example.com/rest/api/3/dashboard/DASH/items/ITM/properties"

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_empty_headers():
    """Test that empty headers dict is handled gracefully."""
    dummy_client = DummyAsyncClient("https://jira.example.com")
    ds = JiraDataSource(JiraClient(dummy_client))
    await ds.get_dashboard_item_property_keys("d", "i", headers={})

# 2. Edge Test Cases

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_none_client_raises():
    """Test that ValueError is raised if client.get_client() returns None."""
    class BrokenJiraClient:
        def get_client(self):
            return None
    with pytest.raises(ValueError, match="HTTP client is not initialized"):
        JiraDataSource(BrokenJiraClient())

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_missing_get_base_url():
    """Test that ValueError is raised if client has no get_base_url method."""
    class NoBaseUrlClient:
        pass
    class DummyJiraClient:
        def get_client(self):
            return NoBaseUrlClient()
    with pytest.raises(ValueError, match="HTTP client does not have get_base_url method"):
        JiraDataSource(DummyJiraClient())

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_execute_raises():
    """Test that exceptions in _client.execute are propagated."""
    error = RuntimeError("execute failed")
    dummy_client = DummyAsyncClient("https://jira.example.com", raise_on_execute=error)
    ds = JiraDataSource(JiraClient(dummy_client))
    with pytest.raises(RuntimeError, match="execute failed"):
        await ds.get_dashboard_item_property_keys("d", "i")

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_concurrent_calls():
    """Test concurrent async calls do not interfere with each other."""
    dummy_client = DummyAsyncClient("https://jira.example.com", execute_result={"keys": ["one"]})
    ds = JiraDataSource(JiraClient(dummy_client))
    # Run two calls concurrently with different params
    results = await asyncio.gather(
        ds.get_dashboard_item_property_keys("dashA", "itemA"),
        ds.get_dashboard_item_property_keys("dashB", "itemB"),
    )
    for r in results:
        pass

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_path_param_types():
    """Test that non-string dashboardId/itemId are converted to string in path."""
    dummy_client = DummyAsyncClient("https://jira.example.com")
    ds = JiraDataSource(JiraClient(dummy_client))
    await ds.get_dashboard_item_property_keys(123, 456)

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_headers_various_types():
    """Test headers with bool, int, None, list are stringified correctly."""
    dummy_client = DummyAsyncClient("https://jira.example.com")
    ds = JiraDataSource(JiraClient(dummy_client))
    headers = {"A": True, "B": None, "C": [1, 2], "D": False}
    await ds.get_dashboard_item_property_keys("d", "i", headers=headers)

# 3. Large Scale Test Cases

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_many_concurrent():
    """Test many concurrent calls for scalability and no cross-talk."""
    dummy_client = DummyAsyncClient("https://jira.example.com", execute_result={"keys": ["z"]})
    ds = JiraDataSource(JiraClient(dummy_client))
    # 50 concurrent calls with unique params
    tasks = [
        ds.get_dashboard_item_property_keys(f"dash{i}", f"item{i}")
        for i in range(50)
    ]
    results = await asyncio.gather(*tasks)

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_large_headers():
    """Test with a large number of headers."""
    dummy_client = DummyAsyncClient("https://jira.example.com")
    ds = JiraDataSource(JiraClient(dummy_client))
    headers = {f"X-{i}": i for i in range(200)}
    await ds.get_dashboard_item_property_keys("d", "i", headers=headers)
    # All headers should be stringified
    for i in range(200):
        pass

# 4. Throughput Test Cases

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_throughput_small_load():
    """Throughput: test small batch of requests executes quickly and correctly."""
    dummy_client = DummyAsyncClient("https://jira.example.com", execute_result={"keys": ["foo"]})
    ds = JiraDataSource(JiraClient(dummy_client))
    tasks = [ds.get_dashboard_item_property_keys("d", f"i{i}") for i in range(5)]
    results = await asyncio.gather(*tasks)

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_throughput_medium_load():
    """Throughput: test medium batch of requests executes correctly."""
    dummy_client = DummyAsyncClient("https://jira.example.com", execute_result={"keys": ["bar"]})
    ds = JiraDataSource(JiraClient(dummy_client))
    tasks = [ds.get_dashboard_item_property_keys("d", f"i{i}") for i in range(25)]
    results = await asyncio.gather(*tasks)

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_throughput_varied_params():
    """Throughput: test batch with varied dashboardId/itemId and headers."""
    dummy_client = DummyAsyncClient("https://jira.example.com", execute_result={"keys": ["baz"]})
    ds = JiraDataSource(JiraClient(dummy_client))
    tasks = [
        ds.get_dashboard_item_property_keys(f"dash{i%3}", f"item{i}", headers={"H": i})
        for i in range(30)
    ]
    results = await asyncio.gather(*tasks)
    for i, r in enumerate(results):
        pass
        # Check that last_request shows correct header for last task (since DummyAsyncClient only stores last)

@pytest.mark.asyncio
async def test_get_dashboard_item_property_keys_throughput_high_volume():
    """Throughput: test high volume of concurrent requests (but <1000)."""
    dummy_client = DummyAsyncClient("https://jira.example.com", execute_result={"keys": ["hv"]})
    ds = JiraDataSource(JiraClient(dummy_client))
    tasks = [ds.get_dashboard_item_property_keys("d", f"i{i}") for i in range(100)]
    results = await asyncio.gather(*tasks)
# 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-JiraDataSource.get_dashboard_item_property_keys-mhpbxsd1 and push.