⚡️ Speed up function get_optional_user_store_api_key by 10% in PR #11565 (refactor/framework-agnostic-auth-service)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #11565

If you approve this dependent PR, these changes will be merged into the original PR branch refactor/framework-agnostic-auth-service.

This PR will be automatically closed if the original PR is merged.

---

📄 10% (0.10x) speedup for get_optional_user_store_api_key in src/backend/base/langflow/api/v1/store.py

⏱️ Runtime : 8.14 milliseconds → 7.38 milliseconds (best of 11 runs)

📝 Explanation and details

The optimization achieves a 10% speedup by introducing a module-level cache for the auth service instance, eliminating repeated service lookups.

Key Changes

Before: Each call to decrypt_api_key() invoked _auth_service() → get_auth_service(), performing a fresh service resolution every time.

After: The _resolve_auth_service() function caches the auth service in _cached_auth_service on first access, returning the cached instance on subsequent calls.

Why This Is Faster

The line profiler reveals the core bottleneck:

• Original: decrypt_api_key() spent 285ms total, averaging 564μs per call (506 hits)
• Optimized: Same function spent 224ms total, averaging 444μs per call (506 hits)

This ~120μs reduction per call (~21% faster per invocation) comes from avoiding the service resolution overhead in get_auth_service(). Service resolution typically involves:

• Dependency injection container lookups
• Potential lazy initialization
• Function call overhead through the indirection layer

By caching the service instance, we pay this cost once per process lifetime instead of once per decryption operation.

Impact on Workloads

This optimization particularly benefits scenarios where:

1. High-frequency decryption: The test_large_scale_many_users_decrypts_correctly test (500 users) demonstrates consistent gains when decrypting multiple API keys in succession
2. API request handling: Each call to get_optional_user_store_api_key() that reaches the decryption path (98.7% of total time in the original) benefits from the cached lookup
3. Concurrent requests: Multiple threads/workers reuse the same cached auth service instance, multiplying the savings

The optimization is transparent to callers—no API changes, no behavioral differences—making it safe for existing code paths while delivering measurable performance gains in decryption-heavy workloads.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from types import SimpleNamespace # simple container for user-like objects
from typing import List
from unittest.mock import ( # for patching external dependencies and spying
Mock, patch)

imports

import pytest # used for our unit tests
from langflow.api.v1.store import get_optional_user_store_api_key

def test_returns_none_when_store_api_key_is_none():
# Create a lightweight user-like object with store_api_key set to None
user = SimpleNamespace(store_api_key=None)
# When store_api_key is falsy (None), the function must return None immediately
codeflash_output = get_optional_user_store_api_key(user)

def test_returns_none_when_store_api_key_is_empty_string():
# Empty string is falsy in Python; function checks if not user.store_api_key
user = SimpleNamespace(store_api_key="")
# The function should treat empty string as absence and return None
codeflash_output = get_optional_user_store_api_key(user)

def test_successful_decryption_returns_decrypted_value():
# Prepare a user with a non-empty (truthy) store_api_key
encrypted = "enc-123"
user = SimpleNamespace(store_api_key=encrypted)

# Patch the get_auth_service function so decrypt_api_key returns a known value.
# We patch the dependency langflow.services.deps.get_auth_service, because
# decrypt_api_key in langflow.services.auth.utils calls it internally.
fake_service = SimpleNamespace(decrypt_api_key=lambda s: f"decrypted:{s}")
with patch("langflow.services.deps.get_auth_service", return_value=fake_service):
    # The function should return the decrypted value provided by our fake service
    codeflash_output = get_optional_user_store_api_key(user); result = codeflash_output

def test_decryption_raises_exception_returns_original_and_logs_exception():
# When the underlying decrypt path raises, get_optional_user_store_api_key must
# catch the exception and return the original stored API key.
encrypted = "enc-broken"
user = SimpleNamespace(store_api_key=encrypted)

# Create a fake auth service whose decrypt_api_key raises an Exception
def raise_exc(_):
    raise ValueError("decryption failed")

fake_service = SimpleNamespace(decrypt_api_key=raise_exc)

# Also patch the logger.exception on the module to verify it gets called.
with patch("langflow.services.deps.get_auth_service", return_value=fake_service):
    with patch("langflow.api.v1.store.logger") as fake_logger:
        # Call the function; it should not propagate the exception
        codeflash_output = get_optional_user_store_api_key(user); result = codeflash_output

def test_decrypt_returns_none_propagates_none():
# If decrypt_api_key returns None (unusual but possible), the function should
# return whatever decrypt_api_key returns (i.e., None).
user = SimpleNamespace(store_api_key="enc-none")

fake_service = SimpleNamespace(decrypt_api_key=lambda s: None)
with patch("langflow.services.deps.get_auth_service", return_value=fake_service):
    codeflash_output = get_optional_user_store_api_key(user); result = codeflash_output

def test_whitespace_store_api_key_is_decrypted_not_treated_as_empty():
# A whitespace-only string is truthy and should be passed to decryption.
whitespace_key = " "
user = SimpleNamespace(store_api_key=whitespace_key)

captured: List[str] = []

# Define a decrypt function that captures its input and returns a marker
def capture_and_return(val):
    captured.append(val)
    return "ok"

fake_service = SimpleNamespace(decrypt_api_key=capture_and_return)
with patch("langflow.services.deps.get_auth_service", return_value=fake_service):
    codeflash_output = get_optional_user_store_api_key(user); result = codeflash_output

def test_non_string_store_api_key_behaviour_numeric_zero_is_treated_as_absent():
# If store_api_key is numeric zero (0), if not user.store_api_key will treat it
# as falsy and return None. This checks the function follows Python truthiness.
user = SimpleNamespace(store_api_key=0)
codeflash_output = get_optional_user_store_api_key(user)

def test_non_string_store_api_key_truthy_numeric_passes_to_decrypt():
# If store_api_key is a truthy non-string (e.g., 42), it will be passed to decrypt.
user = SimpleNamespace(store_api_key=42)
captured: List[object] = []

def capture(val):
    captured.append(val)
    return "decrypted-number"

fake_service = SimpleNamespace(decrypt_api_key=capture)
with patch("langflow.services.deps.get_auth_service", return_value=fake_service):
    codeflash_output = get_optional_user_store_api_key(user); result = codeflash_output

def test_large_scale_many_users_decrypts_correctly():
# Create a substantial list of users (500) to exercise repeated calls and ensure
# the function behaves consistently and scales reasonably for many invocations.
n = 500
users = [SimpleNamespace(store_api_key=f"key-{i}") for i in range(n)]

# Create an auth service that returns a deterministic mapping for each key.
def decrypt_func(s):
    # Simple transformation to verify mapping; s should be the exact key string.
    return f"dec-{s}"

fake_service = SimpleNamespace(decrypt_api_key=decrypt_func)
with patch("langflow.services.deps.get_auth_service", return_value=fake_service):
    results = [get_optional_user_store_api_key(u) for u in users]

# Verify that each input was transformed correctly and order preserved
expected = [f"dec-key-{i}" for i in range(n)]

def test_function_does_not_mutate_user_object():
# The function should not change the user object passed in.
original_key = "immutable-key"
user = SimpleNamespace(store_api_key=original_key)

fake_service = SimpleNamespace(decrypt_api_key=lambda s: "x")
with patch("langflow.services.deps.get_auth_service", return_value=fake_service):
    codeflash_output = get_optional_user_store_api_key(user); _ = codeflash_output

codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

#------------------------------------------------
from unittest.mock import MagicMock, Mock, patch

imports

import pytest
from langflow.api.utils import CurrentActiveUser
from langflow.api.v1.store import get_optional_user_store_api_key

class TestGetOptionalUserStoreApiKeyBasic:
"""Basic test cases for normal functionality."""

To edit these changes git checkout codeflash/optimize-pr11565-2026-02-03T20.36.13 and push.

[coderabbitai]

Important

Review skipped

Bot user detected.

To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

• 🔍 Trigger a full review

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[codecov]

Codecov Report

❌ Patch coverage is 77.14885% with 109 lines in your changes missing coverage. Please review.
✅ Project coverage is 35.47%. Comparing base (84958cf) to head (ec35b84).
⚠️ Report is 97 commits behind head on main.

Files with missing lines	Patch %	Lines
src/backend/base/langflow/services/auth/service.py	69.93%	86 Missing ⚠️
src/backend/base/langflow/services/auth/base.py	88.33%	7 Missing ⚠️
src/backend/base/langflow/api/v1/models.py	0.00%	4 Missing ⚠️
src/backend/base/langflow/services/auth/utils.py	92.59%	4 Missing ⚠️
src/backend/base/langflow/api/v1/store.py	0.00%	2 Missing ⚠️
...backend/base/langflow/services/variable/service.py	77.77%	2 Missing ⚠️
src/backend/base/langflow/api/v1/users.py	50.00%	1 Missing ⚠️
src/backend/base/langflow/api/v1/variable.py	0.00%	1 Missing ⚠️
src/backend/base/langflow/api/v2/mcp.py	66.66%	1 Missing ⚠️
src/lfx/src/lfx/services/manager.py	93.75%	0 Missing and 1 partial ⚠️

❌ Your project status has failed because the head coverage (41.91%) is below the target coverage (60.00%). You can increase the head coverage or adjust the target coverage.

Additional details and impacted files

@@            Coverage Diff             @@
##             main   #11575      +/-   ##
==========================================
+ Coverage   35.34%   35.47%   +0.12%     
==========================================
  Files        1436     1438       +2     
  Lines       69241    69324      +83     
  Branches    10071    10063       -8     
==========================================
+ Hits        24476    24591     +115     
+ Misses      43515    43483      -32     
  Partials     1250     1250              

Flag	Coverage Δ
lfx	41.91% <95.65%> (+0.02%)	⬆️

Flags with carried forward coverage won't be shown. Click here to find out more.

Files with missing lines	Coverage Δ
src/backend/base/langflow/__main__.py	56.30% <100.00%> (+0.30%)	⬆️
src/backend/base/langflow/api/v1/api_key.py	73.33% <100.00%> (ø)
src/backend/base/langflow/api/v1/login.py	41.86% <100.00%> (ø)
src/backend/base/langflow/api/v1/mcp.py	72.57% <100.00%> (ø)
src/backend/base/langflow/api/v1/mcp_projects.py	41.28% <100.00%> (ø)
src/backend/base/langflow/api/v2/schemas.py	100.00% <100.00%> (ø)
src/backend/base/langflow/services/auth/factory.py	100.00% <100.00%> (+10.00%)	⬆️
...kend/base/langflow/services/auth/mcp_encryption.py	73.07% <100.00%> (-1.93%)	⬇️
src/backend/base/langflow/services/deps.py	87.50% <100.00%> (+0.54%)	⬆️
...rc/backend/base/langflow/services/event_manager.py	75.42% <100.00%> (ø)
... and 14 more

... and 13 files with indirect coverage changes

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[ogabrielluiz]

Closing automated codeflash PR.