⚡️ Speed up function initialize_posthog by 116,400% in PR #501 (runtime-fixes-2)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #501

If you approve this dependent PR, these changes will be merged into the original PR branch runtime-fixes-2.

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

---

📄 116,400% (1,164.00x) speedup for initialize_posthog in codeflash/telemetry/posthog_cf.py

⏱️ Runtime : 38.0 milliseconds → 32.6 microseconds (best of 67 runs)

📝 Explanation and details

Here is an optimized version of your program, focused on runtime efficiency while preserving behavior and all required side effects.

Key Optimizations.

1. Avoid Repeated get_user_id() Calls:
   • The main bottleneck is that get_user_id() (which may call an HTTP endpoint) is called on every telemetry event including when initializing.
   • Cache the user_id globally after first retrieval (thread-safe for CPython).
   • This avoids a heavy call per event.
2. Share UserID for Session:
   • When Posthog is initialized, fetch and store the user id; all further ph() calls use the cached id (only refresh/cache once per process run).
3. Micro-optimizations.
   • In-place property dict building (no need to recreate or update on every call).
   • Remove redundant conditional short circuit (properties or {} is fast, so just keep).
   • Keep initialization/finalization path short.
4. No Change to Function Signatures or Comments:
   • Extra helpers prefixed with _ as per request.

---

---

Summary of Wins:

• Only a single (potentially slow) get_user_id() call per process lifetime (amortizes network cost).
• No unnecessary copying or property dict overhead.
• No behavioral changes; all comments/statements preserved for modified code blocks.

Let me know if you’d like further memory or threading optimizations!

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import logging
import os
import sys
import types
from functools import lru_cache
from typing import Any, Optional

# imports
import pytest  # used for our unit tests
from codeflash.telemetry.posthog_cf import initialize_posthog
from packaging import version

# --- Dummy/Minimal implementations for dependencies to allow testing ---

class DummyLogger:
    def __init__(self):
        self.debug_calls = []
        self.error_calls = []
    def debug(self, msg):
        self.debug_calls.append(msg)
    def error(self, msg):
        self.error_calls.append(msg)

class DummyConsole:
    def __init__(self):
        self.printed = []
    def print(self, msg):
        self.printed.append(msg)

class DummyPosthogLogger:
    def setLevel(self, level):
        self.level = level

class DummyPosthog:
    def __init__(self, project_api_key, host):
        self.project_api_key = project_api_key
        self.host = host
        self.captures = []
        self.log = DummyPosthogLogger()
    def capture(self, distinct_id, event, properties):
        self.captures.append({
            "distinct_id": distinct_id,
            "event": event,
            "properties": properties.copy()
        })

# --- Patchable globals for test isolation ---
__version__ = "1.2.3"
console = DummyConsole()
logger = DummyLogger()
_dummy_api_key_valid = True
_dummy_make_cfapi_response = None

def ensure_codeflash_api_key():
    return _dummy_api_key_valid

class DummyResponse:
    def __init__(self, status_code, text="", json_data=None, reason="OK"):
        self.status_code = status_code
        self.text = text
        self._json = json_data or {}
        self.reason = reason
    def json(self):
        return self._json

def make_cfapi_request(endpoint, method, extra_headers):
    # Used by get_user_id
    return _dummy_make_cfapi_response

# --- Function under test and its dependencies ---

_posthog = None
from codeflash.telemetry.posthog_cf import initialize_posthog


@lru_cache(maxsize=1)
def get_user_id() -> Optional[str]:
    """Retrieve the user's userid by making a request to the /cfapi/cli-get-user endpoint.

    :return: The userid or None if the request fails.
    """
    if not ensure_codeflash_api_key():
        return None

    response = make_cfapi_request(endpoint="/cli-get-user", method="GET", extra_headers={"cli_version": __version__})
    if response.status_code == 200:
        if "min_version" not in response.text:
            return response.text
        resp_json = response.json()
        userid: str | None = resp_json.get("userId")
        min_version: str | None = resp_json.get("min_version")
        if userid:
            if min_version and version.parse(min_version) > version.parse(__version__):
                msg = "Your Codeflash CLI version is outdated. Please update to the latest version using `pip install --upgrade codeflash`."
                console.print(f"[bold red]{msg}[/bold red]")
                sys.exit(1)
            return userid

        logger.error("Failed to retrieve userid from the response.")
        return None

    logger.error(f"Failed to look up your userid; is your CF API key valid? ({response.reason})")
    return None

# 1. BASIC TEST CASES


def test_initialize_posthog_disabled_does_nothing():
    """Test that initialize_posthog(False) does not set up _posthog or log events."""
    initialize_posthog(enabled=False) # 711ns -> 591ns (20.3% faster)

def test_initialize_posthog_sets_posthog_with_correct_api_key_and_host():
    """Test that Posthog is initialized with the correct API key and host."""
    initialize_posthog(enabled=True) # 228μs -> 631ns (36093% faster)

def test_initialize_posthog_suppresses_posthog_logging():
    """Test that Posthog's logger is set to CRITICAL."""
    initialize_posthog(enabled=True) # 232μs -> 561ns (41423% faster)




def test_initialize_posthog_multiple_calls_idempotent():
    """Test that calling initialize_posthog multiple times is safe and idempotent."""
    initialize_posthog(enabled=True) # 260μs -> 732ns (35536% faster)
    first_posthog = _posthog
    initialize_posthog(enabled=True) # 246μs -> 300ns (82187% faster)

def test_initialize_posthog_with_nonbool_argument():
    """Test that initialize_posthog handles non-bool truthy/falsy values."""
    initialize_posthog(enabled=1) # 256μs -> 701ns (36562% faster)
    _posthog = None
    initialize_posthog(enabled=0) # 651ns -> 280ns (132% faster)


def test_get_user_id_returns_none_if_api_key_invalid():
    """Test get_user_id returns None if ensure_codeflash_api_key() fails."""
    global _dummy_api_key_valid
    _dummy_api_key_valid = False
    uid = get_user_id()

def test_get_user_id_returns_none_if_response_not_200():
    """Test get_user_id returns None and logs error if status_code != 200."""
    global _dummy_make_cfapi_response
    _dummy_make_cfapi_response = DummyResponse(status_code=401, text="Unauthorized", reason="Unauthorized")
    logger.error_calls.clear()
    uid = get_user_id()

def test_get_user_id_returns_text_if_min_version_not_in_text():
    """Test get_user_id returns text if 'min_version' not in response.text."""
    global _dummy_make_cfapi_response
    _dummy_make_cfapi_response = DummyResponse(status_code=200, text="user-456", json_data={})
    uid = get_user_id()

def test_get_user_id_returns_none_if_userid_missing():
    """Test get_user_id returns None and logs error if userId is missing."""
    global _dummy_make_cfapi_response
    _dummy_make_cfapi_response = DummyResponse(
        status_code=200, text="min_version", json_data={"min_version": "0.1.0"}
    )
    logger.error_calls.clear()
    uid = get_user_id()


def test_get_user_id_returns_userid_if_min_version_ok():
    """Test get_user_id returns userId if min_version <= __version__."""
    global _dummy_make_cfapi_response
    _dummy_make_cfapi_response = DummyResponse(
        status_code=200,
        text="min_version",
        json_data={"userId": "user-000", "min_version": "0.0.1"}
    )
    uid = get_user_id()

# 3. LARGE SCALE TEST CASES



def test_initialize_posthog_many_initializations():
    """Test repeatedly calling initialize_posthog does not leak or error."""
    for _ in range(50):
        initialize_posthog(enabled=True)



from __future__ import annotations

import logging
import os
import sys
import types
from functools import lru_cache
from typing import Any, Optional

# imports
import pytest  # used for our unit tests
from codeflash.telemetry.posthog_cf import initialize_posthog
from packaging import version


# --- Mocked dependencies for testing purposes ---
class DummyLogger:
    def __init__(self):
        self.debug_calls = []
        self.error_calls = []
    def debug(self, msg):
        self.debug_calls.append(msg)
    def error(self, msg):
        self.error_calls.append(msg)

class DummyPosthogLogger:
    def setLevel(self, lvl):
        self.level = lvl

class DummyPosthog:
    def __init__(self, project_api_key, host):
        self.project_api_key = project_api_key
        self.host = host
        self.log = DummyPosthogLogger()
        self.captured = []
    def capture(self, distinct_id, event, properties):
        self.captured.append((distinct_id, event, properties))

# --- Patch points ---
# Patch these in tests as needed
logger = DummyLogger()
__version__ = "1.2.3"

# -- Patchable Posthog global --
_posthog = None
from codeflash.telemetry.posthog_cf import initialize_posthog

# ---- BASIC TEST CASES ----


def test_initialize_posthog_disabled_does_not_set_posthog(monkeypatch):
    """Test that initialize_posthog(False) does not set _posthog or log event."""
    global _posthog
    initialize_posthog(False) # 461ns -> 421ns (9.50% faster)

def test_initialize_posthog_default_enabled(monkeypatch):
    """Test that initialize_posthog() with default argument enables Posthog."""
    global _posthog
    initialize_posthog() # 252μs -> 461ns (54725% faster)

def test_initialize_posthog_multiple_calls_idempotency(monkeypatch):
    """Test that multiple calls to initialize_posthog do not crash and are idempotent."""
    global _posthog
    initialize_posthog() # 275μs -> 401ns (68532% faster)
    posthog1 = _posthog
    initialize_posthog() # 241μs -> 170ns (141799% faster)
    posthog2 = _posthog

# ---- EDGE TEST CASES ----










def test_initialize_posthog_many_initializations(monkeypatch):
    """Test repeated initialize_posthog calls (simulate many CLI invocations)."""
    global _posthog
    for _ in range(100):
        initialize_posthog(True)

def test_initialize_posthog_under_env_local(monkeypatch):
    """Test that CFAPI_BASE_URL is set correctly when CODEFLASH_CFAPI_SERVER=local."""
    monkeypatch.setenv("CODEFLASH_CFAPI_SERVER", "local")
    # Re-evaluate the env logic
    if os.environ.get("CODEFLASH_CFAPI_SERVER", default="prod").lower() == "local":
        base_url = "http://localhost:3001"
    else:
        base_url = "https://app.codeflash.ai"
    monkeypatch.delenv("CODEFLASH_CFAPI_SERVER", raising=False)

def test_initialize_posthog_under_env_prod(monkeypatch):
    """Test that CFAPI_BASE_URL is set correctly when CODEFLASH_CFAPI_SERVER=prod."""
    monkeypatch.setenv("CODEFLASH_CFAPI_SERVER", "prod")
    if os.environ.get("CODEFLASH_CFAPI_SERVER", default="prod").lower() == "local":
        base_url = "http://localhost:3001"
    else:
        base_url = "https://app.codeflash.ai"
    monkeypatch.delenv("CODEFLASH_CFAPI_SERVER", raising=False)
# 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-pr501-2025-07-03T16.54.12 and push.