posthoganalytics 6.8.0__py3-none-any.whl → 6.9.0__py3-none-any.whl

posthoganalytics/__init__.py

@@ -10,6 +10,9 @@ from posthoganalytics.contexts import (
     tag as inner_tag,
     set_context_session as inner_set_context_session,
     identify_context as inner_identify_context,
+    set_capture_exception_code_variables_context as inner_set_capture_exception_code_variables_context,
+    set_code_variables_mask_patterns_context as inner_set_code_variables_mask_patterns_context,
+    set_code_variables_ignore_patterns_context as inner_set_code_variables_ignore_patterns_context,
 )
 from posthoganalytics.feature_flags import InconclusiveMatchError, RequiresServerEvaluation
 from posthoganalytics.types import FeatureFlag, FlagsAndPayloads, FeatureFlagResult
@@ -20,13 +23,14 @@ __version__ = VERSION
 """Context management."""
 
 
-def new_context(fresh=False, capture_exceptions=True):
+def new_context(fresh=False, capture_exceptions=True, client=None):
     """
     Create a new context scope that will be active for the duration of the with block.
 
     Args:
         fresh: Whether to start with a fresh context (default: False)
         capture_exceptions: Whether to capture exceptions raised within the context (default: True)
+        client: Optional Posthog client instance to use for this context (default: None)
 
     Examples:
         ```python
@@ -39,7 +43,9 @@ def new_context(fresh=False, capture_exceptions=True):
     Category:
         Contexts
     """
-    return inner_new_context(fresh=fresh, capture_exceptions=capture_exceptions)
+    return inner_new_context(
+        fresh=fresh, capture_exceptions=capture_exceptions, client=client
+    )
 
 
 def scoped(fresh=False, capture_exceptions=True):
@@ -103,6 +109,27 @@ def identify_context(distinct_id: str):
     return inner_identify_context(distinct_id)
 
 
+def set_capture_exception_code_variables_context(enabled: bool):
+    """
+    Set whether code variables are captured for the current context.
+    """
+    return inner_set_capture_exception_code_variables_context(enabled)
+
+
+def set_code_variables_mask_patterns_context(mask_patterns: list):
+    """
+    Variable names matching these patterns will be masked with *** when capturing code variables.
+    """
+    return inner_set_code_variables_mask_patterns_context(mask_patterns)
+
+
+def set_code_variables_ignore_patterns_context(ignore_patterns: list):
+    """
+    Variable names matching these patterns will be ignored completely when capturing code variables.
+    """
+    return inner_set_code_variables_ignore_patterns_context(ignore_patterns)
+
+
 def tag(name: str, value: Any):
     """
     Add a tag to the current context.

posthoganalytics/client.py

@@ -19,6 +19,9 @@ from posthoganalytics.exception_utils import (
     handle_in_app,
     exception_is_already_captured,
     mark_exception_as_captured,
+    try_attach_code_variables_to_frames,
+    DEFAULT_CODE_VARIABLES_MASK_PATTERNS,
+    DEFAULT_CODE_VARIABLES_IGNORE_PATTERNS,
 )
 from posthoganalytics.feature_flags import (
     InconclusiveMatchError,
@@ -39,6 +42,9 @@ from posthoganalytics.contexts import (
     _get_current_context,
     get_context_distinct_id,
     get_context_session_id,
+    get_capture_exception_code_variables_context,
+    get_code_variables_mask_patterns_context,
+    get_code_variables_ignore_patterns_context,
     new_context,
 )
 from posthoganalytics.types import (
@@ -178,6 +184,9 @@ class Client(object):
         before_send=None,
         flag_fallback_cache_url=None,
         enable_local_evaluation=True,
+        capture_exception_code_variables=False,
+        code_variables_mask_patterns=None,
+        code_variables_ignore_patterns=None,
     ):
         """
         Initialize a new PostHog client instance.
@@ -233,6 +242,18 @@ class Client(object):
         self.privacy_mode = privacy_mode
         self.enable_local_evaluation = enable_local_evaluation
 
+        self.capture_exception_code_variables = capture_exception_code_variables
+        self.code_variables_mask_patterns = (
+            code_variables_mask_patterns
+            if code_variables_mask_patterns is not None
+            else DEFAULT_CODE_VARIABLES_MASK_PATTERNS
+        )
+        self.code_variables_ignore_patterns = (
+            code_variables_ignore_patterns
+            if code_variables_ignore_patterns is not None
+            else DEFAULT_CODE_VARIABLES_IGNORE_PATTERNS
+        )
+
         if project_root is None:
             try:
                 project_root = os.getcwd()
@@ -979,6 +1000,34 @@ class Client(object):
                 **properties,
             }
 
+            context_enabled = get_capture_exception_code_variables_context()
+            context_mask = get_code_variables_mask_patterns_context()
+            context_ignore = get_code_variables_ignore_patterns_context()
+
+            enabled = (
+                context_enabled
+                if context_enabled is not None
+                else self.capture_exception_code_variables
+            )
+            mask_patterns = (
+                context_mask
+                if context_mask is not None
+                else self.code_variables_mask_patterns
+            )
+            ignore_patterns = (
+                context_ignore
+                if context_ignore is not None
+                else self.code_variables_ignore_patterns
+            )
+
+            if enabled:
+                try_attach_code_variables_to_frames(
+                    all_exceptions_with_trace_and_in_app,
+                    exc_info,
+                    mask_patterns=mask_patterns,
+                    ignore_patterns=ignore_patterns,
+                )
+
             if self.log_captured_exceptions:
                 self.log.exception(exception, extra=kwargs)
 

posthoganalytics/contexts.py

@@ -22,6 +22,9 @@ class ContextScope:
         self.session_id: Optional[str] = None
         self.distinct_id: Optional[str] = None
         self.tags: Dict[str, Any] = {}
+        self.capture_exception_code_variables: Optional[bool] = None
+        self.code_variables_mask_patterns: Optional[list] = None
+        self.code_variables_ignore_patterns: Optional[list] = None
 
     def set_session_id(self, session_id: str):
         self.session_id = session_id
@@ -32,6 +35,15 @@ class ContextScope:
     def add_tag(self, key: str, value: Any):
         self.tags[key] = value
 
+    def set_capture_exception_code_variables(self, enabled: bool):
+        self.capture_exception_code_variables = enabled
+
+    def set_code_variables_mask_patterns(self, mask_patterns: list):
+        self.code_variables_mask_patterns = mask_patterns
+
+    def set_code_variables_ignore_patterns(self, ignore_patterns: list):
+        self.code_variables_ignore_patterns = ignore_patterns
+
     def get_parent(self):
         return self.parent
 
@@ -59,6 +71,27 @@ class ContextScope:
             tags.update(new_tags)
         return tags
 
+    def get_capture_exception_code_variables(self) -> Optional[bool]:
+        if self.capture_exception_code_variables is not None:
+            return self.capture_exception_code_variables
+        if self.parent is not None and not self.fresh:
+            return self.parent.get_capture_exception_code_variables()
+        return None
+
+    def get_code_variables_mask_patterns(self) -> Optional[list]:
+        if self.code_variables_mask_patterns is not None:
+            return self.code_variables_mask_patterns
+        if self.parent is not None and not self.fresh:
+            return self.parent.get_code_variables_mask_patterns()
+        return None
+
+    def get_code_variables_ignore_patterns(self) -> Optional[list]:
+        if self.code_variables_ignore_patterns is not None:
+            return self.code_variables_ignore_patterns
+        if self.parent is not None and not self.fresh:
+            return self.parent.get_code_variables_ignore_patterns()
+        return None
+
 
 _context_stack: contextvars.ContextVar[Optional[ContextScope]] = contextvars.ContextVar(
     "posthog_context_stack", default=None
@@ -243,6 +276,54 @@ def get_context_distinct_id() -> Optional[str]:
     return None
 
 
+def set_capture_exception_code_variables_context(enabled: bool) -> None:
+    """
+    Set whether code variables are captured for the current context.
+    """
+    current_context = _get_current_context()
+    if current_context:
+        current_context.set_capture_exception_code_variables(enabled)
+
+
+def set_code_variables_mask_patterns_context(mask_patterns: list) -> None:
+    """
+    Variable names matching these patterns will be masked with *** when capturing code variables.
+    """
+    current_context = _get_current_context()
+    if current_context:
+        current_context.set_code_variables_mask_patterns(mask_patterns)
+
+
+def set_code_variables_ignore_patterns_context(ignore_patterns: list) -> None:
+    """
+    Variable names matching these patterns will be ignored completely when capturing code variables.
+    """
+    current_context = _get_current_context()
+    if current_context:
+        current_context.set_code_variables_ignore_patterns(ignore_patterns)
+
+
+def get_capture_exception_code_variables_context() -> Optional[bool]:
+    current_context = _get_current_context()
+    if current_context:
+        return current_context.get_capture_exception_code_variables()
+    return None
+
+
+def get_code_variables_mask_patterns_context() -> Optional[list]:
+    current_context = _get_current_context()
+    if current_context:
+        return current_context.get_code_variables_mask_patterns()
+    return None
+
+
+def get_code_variables_ignore_patterns_context() -> Optional[list]:
+    current_context = _get_current_context()
+    if current_context:
+        return current_context.get_code_variables_ignore_patterns()
+    return None
+
+
 F = TypeVar("F", bound=Callable[..., Any])
 
 

posthoganalytics/exception_utils.py

@@ -5,6 +5,7 @@
 # 💖open source (under MIT License)
 # We want to keep payloads as similar to Sentry as possible for easy interoperability
 
+import json
 import linecache
 import os
 import re
@@ -26,6 +27,7 @@ from typing import (  # noqa: F401
     Union,
     cast,
     TYPE_CHECKING,
+    Pattern,
 )
 
 from posthoganalytics.args import ExcInfo, ExceptionArg  # noqa: F401
@@ -40,6 +42,42 @@ except ImportError:
 
 DEFAULT_MAX_VALUE_LENGTH = 1024
 
+DEFAULT_CODE_VARIABLES_MASK_PATTERNS = [
+    r"(?i).*password.*",
+    r"(?i).*secret.*",
+    r"(?i).*passwd.*",
+    r"(?i).*pwd.*",
+    r"(?i).*api_key.*",
+    r"(?i).*apikey.*",
+    r"(?i).*auth.*",
+    r"(?i).*credentials.*",
+    r"(?i).*privatekey.*",
+    r"(?i).*private_key.*",
+    r"(?i).*token.*",
+]
+
+DEFAULT_CODE_VARIABLES_IGNORE_PATTERNS = [r"^__.*"]
+
+CODE_VARIABLES_REDACTED_VALUE = "$$_posthog_redacted_based_on_masking_rules_$$"
+
+DEFAULT_TOTAL_VARIABLES_SIZE_LIMIT = 20 * 1024
+
+
+class VariableSizeLimiter:
+    def __init__(self, max_size=DEFAULT_TOTAL_VARIABLES_SIZE_LIMIT):
+        self.max_size = max_size
+        self.current_size = 0
+
+    def can_add(self, size):
+        return self.current_size + size <= self.max_size
+
+    def add(self, size):
+        self.current_size += size
+
+    def get_remaining_space(self):
+        return self.max_size - self.current_size
+
+
 LogLevelStr = Literal["fatal", "critical", "error", "warning", "info", "debug"]
 
 Event = TypedDict(
@@ -884,3 +922,157 @@ def strip_string(value, max_length=None):
             "rem": [["!limit", "x", max_length - 3, max_length]],
         },
     )
+
+
+def _compile_patterns(patterns):
+    compiled = []
+    for pattern in patterns:
+        try:
+            compiled.append(re.compile(pattern))
+        except:
+            pass
+    return compiled
+
+
+def _pattern_matches(name, patterns):
+    for pattern in patterns:
+        if pattern.search(name):
+            return True
+    return False
+
+
+def _serialize_variable_value(value, limiter, max_length=1024):
+    try:
+        if value is None:
+            result = "None"
+        elif isinstance(value, bool):
+            result = str(value)
+        elif isinstance(value, (int, float)):
+            result_size = len(str(value))
+            if not limiter.can_add(result_size):
+                return None
+            limiter.add(result_size)
+            return value
+        elif isinstance(value, str):
+            result = value
+        else:
+            result = json.dumps(value)
+
+        if len(result) > max_length:
+            result = result[: max_length - 3] + "..."
+
+        result_size = len(result)
+        if not limiter.can_add(result_size):
+            return None
+        limiter.add(result_size)
+
+        return result
+    except Exception:
+        try:
+            fallback = f"<{type(value).__name__}>"
+            fallback_size = len(fallback)
+            if not limiter.can_add(fallback_size):
+                return None
+            limiter.add(fallback_size)
+            return fallback
+        except Exception:
+            fallback = "<unserializable object>"
+            fallback_size = len(fallback)
+            if not limiter.can_add(fallback_size):
+                return None
+            limiter.add(fallback_size)
+            return fallback
+
+
+def _is_simple_type(value):
+    return isinstance(value, (type(None), bool, int, float, str))
+
+
+def serialize_code_variables(
+    frame, limiter, mask_patterns=None, ignore_patterns=None, max_length=1024
+):
+    if mask_patterns is None:
+        mask_patterns = []
+    if ignore_patterns is None:
+        ignore_patterns = []
+
+    compiled_mask = _compile_patterns(mask_patterns)
+    compiled_ignore = _compile_patterns(ignore_patterns)
+
+    try:
+        local_vars = frame.f_locals.copy()
+    except Exception:
+        return {}
+
+    simple_vars = {}
+    complex_vars = {}
+
+    for name, value in local_vars.items():
+        if _pattern_matches(name, compiled_ignore):
+            continue
+
+        if _is_simple_type(value):
+            simple_vars[name] = value
+        else:
+            complex_vars[name] = value
+
+    result = {}
+
+    all_vars = {**simple_vars, **complex_vars}
+    ordered_names = list(sorted(simple_vars.keys())) + list(sorted(complex_vars.keys()))
+
+    for name in ordered_names:
+        value = all_vars[name]
+
+        if _pattern_matches(name, compiled_mask):
+            redacted_value = CODE_VARIABLES_REDACTED_VALUE
+            redacted_size = len(redacted_value)
+            if not limiter.can_add(redacted_size):
+                break
+            limiter.add(redacted_size)
+            result[name] = redacted_value
+        else:
+            serialized = _serialize_variable_value(value, limiter, max_length)
+            if serialized is None:
+                break
+            result[name] = serialized
+
+    return result
+
+
+def try_attach_code_variables_to_frames(
+    all_exceptions, exc_info, mask_patterns, ignore_patterns
+):
+    exc_type, exc_value, traceback = exc_info
+
+    if traceback is None:
+        return
+
+    tb_frames = list(iter_stacks(traceback))
+
+    if not tb_frames:
+        return
+
+    limiter = VariableSizeLimiter()
+
+    for exception in all_exceptions:
+        stacktrace = exception.get("stacktrace")
+        if not stacktrace or "frames" not in stacktrace:
+            continue
+
+        serialized_frames = stacktrace["frames"]
+
+        for serialized_frame, tb_item in zip(serialized_frames, tb_frames):
+            if not serialized_frame.get("in_app"):
+                continue
+
+            variables = serialize_code_variables(
+                tb_item.tb_frame,
+                limiter,
+                mask_patterns=mask_patterns,
+                ignore_patterns=ignore_patterns,
+                max_length=1024,
+            )
+
+            if variables:
+                serialized_frame["code_variables"] = variables

posthoganalytics/test/test_exception_capture.py

@@ -32,3 +32,303 @@ def test_excepthook(tmpdir):
         b'"$exception_list": [{"mechanism": {"type": "generic", "handled": true}, "module": null, "type": "ZeroDivisionError", "value": "division by zero", "stacktrace": {"frames": [{"platform": "python", "filename": "app.py", "abs_path"'
         in output
     )
+
+
+def test_code_variables_capture(tmpdir):
+    app = tmpdir.join("app.py")
+    app.write(
+        dedent(
+            """
+    import os
+    from posthoganalytics import Posthog
+    
+    class UnserializableObject:
+        pass
+    
+    posthog = Posthog(
+        'phc_x', 
+        host='https://eu.i.posthog.com', 
+        debug=True, 
+        enable_exception_autocapture=True,
+        capture_exception_code_variables=True,
+        project_root=os.path.dirname(os.path.abspath(__file__))
+    )
+    
+    def trigger_error():
+        my_string = "hello world"
+        my_number = 42
+        my_bool = True
+        my_dict = {"name": "test", "value": 123}
+        my_obj = UnserializableObject()
+        my_password = "secret123"  # Should be masked by default
+        __should_be_ignored = "hidden"  # Should be ignored by default
+        
+        1/0  # Trigger exception
+    
+    def intermediate_function():
+        request_id = "abc-123"
+        user_count = 100
+        is_active = True
+        
+        trigger_error()
+    
+    def process_data():
+        batch_size = 50
+        retry_count = 3
+        
+        intermediate_function()
+    
+    process_data()
+    """
+        )
+    )
+
+    with pytest.raises(subprocess.CalledProcessError) as excinfo:
+        subprocess.check_output([sys.executable, str(app)], stderr=subprocess.STDOUT)
+
+    output = excinfo.value.output
+
+    assert b"ZeroDivisionError" in output
+    assert b"code_variables" in output
+
+    # Variables from trigger_error frame
+    assert b"'my_string': 'hello world'" in output
+    assert b"'my_number': 42" in output
+    assert b"'my_bool': 'True'" in output
+    assert b'"my_dict": "{\\"name\\": \\"test\\", \\"value\\": 123}"' in output
+    assert b'"my_obj": "<UnserializableObject>"' in output
+    assert b"'my_password': '$$_posthog_redacted_based_on_masking_rules_$$'" in output
+    assert b"'__should_be_ignored':" not in output
+
+    # Variables from intermediate_function frame
+    assert b"'request_id': 'abc-123'" in output
+    assert b"'user_count': 100" in output
+    assert b"'is_active': 'True'" in output
+
+    # Variables from process_data frame
+    assert b"'batch_size': 50" in output
+    assert b"'retry_count': 3" in output
+
+
+def test_code_variables_context_override(tmpdir):
+    app = tmpdir.join("app.py")
+    app.write(
+        dedent(
+            """
+    import os
+    import posthog
+    from posthoganalytics import Posthog
+    
+    posthog_client = Posthog(
+        'phc_x', 
+        host='https://eu.i.posthog.com', 
+        debug=True, 
+        enable_exception_autocapture=True,
+        capture_exception_code_variables=False,
+        project_root=os.path.dirname(os.path.abspath(__file__))
+    )
+    
+    def process_data():
+        bank = "should_be_masked"
+        __dunder_var = "should_be_visible"
+        
+        1/0
+    
+    with posthog.new_context(client=posthog_client):
+        posthog.set_capture_exception_code_variables_context(True)
+        posthog.set_code_variables_mask_patterns_context([r"(?i).*bank.*"])
+        posthog.set_code_variables_ignore_patterns_context([])
+        
+        process_data()
+    """
+        )
+    )
+
+    with pytest.raises(subprocess.CalledProcessError) as excinfo:
+        subprocess.check_output([sys.executable, str(app)], stderr=subprocess.STDOUT)
+
+    output = excinfo.value.output
+
+    assert b"ZeroDivisionError" in output
+    assert b"code_variables" in output
+    assert b"'bank': '$$_posthog_redacted_based_on_masking_rules_$$'" in output
+    assert b"'__dunder_var': 'should_be_visible'" in output
+
+
+def test_code_variables_size_limiter(tmpdir):
+    app = tmpdir.join("app.py")
+    app.write(
+        dedent(
+            """
+    import os
+    from posthoganalytics import Posthog
+    
+    posthog = Posthog(
+        'phc_x', 
+        host='https://eu.i.posthog.com', 
+        debug=True, 
+        enable_exception_autocapture=True,
+        capture_exception_code_variables=True,
+        project_root=os.path.dirname(os.path.abspath(__file__))
+    )
+    
+    def trigger_error():
+        var_a = "a" * 2000
+        var_b = "b" * 2000
+        var_c = "c" * 2000
+        var_d = "d" * 2000
+        var_e = "e" * 2000
+        var_f = "f" * 2000
+        var_g = "g" * 2000
+        
+        1/0
+    
+    def intermediate_function():
+        var_h = "h" * 2000
+        var_i = "i" * 2000
+        var_j = "j" * 2000
+        var_k = "k" * 2000
+        var_l = "l" * 2000
+        var_m = "m" * 2000
+        var_n = "n" * 2000
+        
+        trigger_error()
+    
+    def process_data():
+        var_o = "o" * 2000
+        var_p = "p" * 2000
+        var_q = "q" * 2000
+        var_r = "r" * 2000
+        var_s = "s" * 2000
+        var_t = "t" * 2000
+        var_u = "u" * 2000
+        
+        intermediate_function()
+    
+    process_data()
+    """
+        )
+    )
+
+    with pytest.raises(subprocess.CalledProcessError) as excinfo:
+        subprocess.check_output([sys.executable, str(app)], stderr=subprocess.STDOUT)
+
+    output = excinfo.value.output.decode("utf-8")
+
+    assert "ZeroDivisionError" in output
+    assert "code_variables" in output
+
+    captured_vars = []
+    for var_name in [
+        "var_a",
+        "var_b",
+        "var_c",
+        "var_d",
+        "var_e",
+        "var_f",
+        "var_g",
+        "var_h",
+        "var_i",
+        "var_j",
+        "var_k",
+        "var_l",
+        "var_m",
+        "var_n",
+        "var_o",
+        "var_p",
+        "var_q",
+        "var_r",
+        "var_s",
+        "var_t",
+        "var_u",
+    ]:
+        if f"'{var_name}'" in output:
+            captured_vars.append(var_name)
+
+    assert len(captured_vars) > 0
+    assert len(captured_vars) < 21
+
+
+def test_code_variables_disabled_capture(tmpdir):
+    app = tmpdir.join("app.py")
+    app.write(
+        dedent(
+            """
+    import os
+    from posthoganalytics import Posthog
+    
+    posthog = Posthog(
+        'phc_x', 
+        host='https://eu.i.posthog.com', 
+        debug=True, 
+        enable_exception_autocapture=True,
+        capture_exception_code_variables=False,
+        project_root=os.path.dirname(os.path.abspath(__file__))
+    )
+    
+    def trigger_error():
+        my_string = "hello world"
+        my_number = 42
+        my_bool = True
+        
+        1/0
+    
+    trigger_error()
+    """
+        )
+    )
+
+    with pytest.raises(subprocess.CalledProcessError) as excinfo:
+        subprocess.check_output([sys.executable, str(app)], stderr=subprocess.STDOUT)
+
+    output = excinfo.value.output.decode("utf-8")
+
+    assert "ZeroDivisionError" in output
+    assert "'code_variables':" not in output
+    assert '"code_variables":' not in output
+    assert "'my_string'" not in output
+    assert "'my_number'" not in output
+
+
+def test_code_variables_enabled_then_disabled_in_context(tmpdir):
+    app = tmpdir.join("app.py")
+    app.write(
+        dedent(
+            """
+    import os
+    import posthog
+    from posthoganalytics import Posthog
+    
+    posthog_client = Posthog(
+        'phc_x', 
+        host='https://eu.i.posthog.com', 
+        debug=True, 
+        enable_exception_autocapture=True,
+        capture_exception_code_variables=True,
+        project_root=os.path.dirname(os.path.abspath(__file__))
+    )
+    
+    def process_data():
+        my_var = "should not be captured"
+        important_value = 123
+        
+        1/0
+    
+    with posthog.new_context(client=posthog_client):
+        posthog.set_capture_exception_code_variables_context(False)
+        
+        process_data()
+    """
+        )
+    )
+
+    with pytest.raises(subprocess.CalledProcessError) as excinfo:
+        subprocess.check_output([sys.executable, str(app)], stderr=subprocess.STDOUT)
+
+    output = excinfo.value.output.decode("utf-8")
+
+    assert "ZeroDivisionError" in output
+    assert "'code_variables':" not in output
+    assert '"code_variables":' not in output
+    assert "'my_var'" not in output
+    assert "'important_value'" not in output

posthoganalytics/version.py

@@ -1,4 +1,4 @@
-VERSION = "6.8.0"
+VERSION = "6.9.0"
 
 if __name__ == "__main__":
     print(VERSION, end="")  # noqa: T201

{posthoganalytics-6.8.0.dist-info → posthoganalytics-6.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: posthoganalytics
-Version: 6.8.0
+Version: 6.9.0
 Summary: Integrate PostHog into any python application.
 Home-page: https://github.com/posthog/posthog-python
 Author: Posthog

{posthoganalytics-6.8.0.dist-info → posthoganalytics-6.9.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
-posthoganalytics/__init__.py,sha256=vYBBQuWxyCdN2mkFuJgHqGGh0ZcO7WriFy7tEILtpSI,26079
+posthoganalytics/__init__.py,sha256=_zAqJWGGR_saWREp2GioAaZM99qoZyXPB8GXct-z_3U,27256
 posthoganalytics/args.py,sha256=iZ2JWeANiAREJKhS-Qls9tIngjJOSfAVR8C4xFT5sHw,3307
-posthoganalytics/client.py,sha256=GQJSIagCiavxrKeTA1HDTiGmvmwDdtI0pq9Dnr71Mgs,72722
+posthoganalytics/client.py,sha256=8QTaZN84U_NyWCpNMnO7yQtxYw4vfMJ0ixXVikA6FCg,74670
 posthoganalytics/consumer.py,sha256=CiNbJBdyW9jER3ZYCKbX-JFmEDXlE1lbDy1MSl43-a0,4617
-posthoganalytics/contexts.py,sha256=LFSFIYpUFWKTBnGMjV9n1aYHWbAzz5zLJGr2qG34PoE,9405
+posthoganalytics/contexts.py,sha256=Qj8eprL71IVGo4nMtHCs7kIEhezOmxfkYpiPTg-rWjU,12618
 posthoganalytics/exception_capture.py,sha256=1VHBfffrXXrkK0PT8iVgKPpj_R1pGAzG5f3Qw0WF79w,1783
-posthoganalytics/exception_utils.py,sha256=P_75873Y2jayqlLiIkbxCNE7Bc8cM6J9kfrdZ5ZSnA0,26696
+posthoganalytics/exception_utils.py,sha256=DrKNkZdgYXOPtEG5qPvqlPE86nefBc9yazSS5akA34Y,31857
 posthoganalytics/feature_flags.py,sha256=yHjiH6LSvhQgurbsPCHUdGakZKvkzOLdqB8vL3iyhmw,22544
 posthoganalytics/poller.py,sha256=jBz5rfH_kn_bBz7wCB46Fpvso4ttx4uzqIZWvXBCFmQ,595
 posthoganalytics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 posthoganalytics/request.py,sha256=Bsl2c5WwONKPQzwWMmKPX5VgOlwSiIcSNfhXgoz62Y8,6186
 posthoganalytics/types.py,sha256=Dl3aFGX9XUR0wMmK12r2s5Hjan9jL4HpQ9GHpVcEq5U,10207
 posthoganalytics/utils.py,sha256=-0w-OLcCaoldkbBebPzQyBzLJSo9G9yBOg8NDVz7La8,16088
-posthoganalytics/version.py,sha256=xqPIL3Vi5H0V2bZOTQqSHr-lQXEhP8VBNZcmOrTSRUw,87
+posthoganalytics/version.py,sha256=qTlEuCWb-slrdA36sMFDZPyA5fyBwCpQaHtWJmuEIgI,87
 posthoganalytics/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 posthoganalytics/ai/sanitization.py,sha256=owipZ4eJYtd4JTI-CM_klatclXaeaIec3XJBOUfsOnQ,5770
 posthoganalytics/ai/types.py,sha256=arX98hR1PIPeJ3vFikxTlACIh1xPp6aEUw1gBLcKoB0,3273
@@ -38,7 +38,7 @@ posthoganalytics/test/test_before_send.py,sha256=A1_UVMewhHAvO39rZDWfS606vG_X-q0
 posthoganalytics/test/test_client.py,sha256=e1dD9bFplZWROiP35fuyBDguGXC6ZmG5j79Iw2t_NBw,96363
 posthoganalytics/test/test_consumer.py,sha256=HGMfU9PzQ5ZAe_R3kHnZNsMvD7jUjHL-gie0isrvMMk,7107
 posthoganalytics/test/test_contexts.py,sha256=c--hNUIEf6SHQ7H9vdPhU1oLCN0SnD4wDbFr-eLPHDo,7013
-posthoganalytics/test/test_exception_capture.py,sha256=al37Kg6wjzL_IBCFUUXRvkP6nVrqS6IZRCOKSo29Nh8,1063
+posthoganalytics/test/test_exception_capture.py,sha256=i-979ZHfi1KGndhyEkKLRrYVtpUI7OfpE9U8VsNinmU,8993
 posthoganalytics/test/test_feature_flag.py,sha256=9RQwB5eCvVAGrrO7UnR3Z1OidP_YoL4iBl3A83fuAig,6824
 posthoganalytics/test/test_feature_flag_result.py,sha256=z2OgD97r85LKMqCnoCqAs74WjUMucayAtC3qWaITGCA,15898
 posthoganalytics/test/test_feature_flags.py,sha256=b0CcW2JyBRhOxlWX9KOBncqL7OG_VHFX3Z4J6VOlPNs,217352
@@ -47,8 +47,8 @@ posthoganalytics/test/test_request.py,sha256=Zc0VbkjpVmj8mKokQm9rzdgTr0b1U44vvMY
 posthoganalytics/test/test_size_limited_dict.py,sha256=-5IQjIEr_-Dql24M0HusdR_XroOMrtgiT0v6ZQCRvzo,774
 posthoganalytics/test/test_types.py,sha256=bRPHdwVpP7hu7emsplU8UVyzSQptv6PaG5lAoOD_BtM,7595
 posthoganalytics/test/test_utils.py,sha256=sqUTbfweVcxxFRd3WDMFXqPMyU6DvzOBeAOc68Py9aw,9620
-posthoganalytics-6.8.0.dist-info/licenses/LICENSE,sha256=wGf9JBotDkSygFj43m49oiKlFnpMnn97keiZKF-40vE,2450
-posthoganalytics-6.8.0.dist-info/METADATA,sha256=aJLZEPJb-8QghbEJJ3GUEBEAcib56DsCiIs6-kFiwls,6024
-posthoganalytics-6.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-posthoganalytics-6.8.0.dist-info/top_level.txt,sha256=8QsNIqIkBh1p2TXvKp0Em9ZLZKwe3uIqCETyW4s1GOE,17
-posthoganalytics-6.8.0.dist-info/RECORD,,
+posthoganalytics-6.9.0.dist-info/licenses/LICENSE,sha256=wGf9JBotDkSygFj43m49oiKlFnpMnn97keiZKF-40vE,2450
+posthoganalytics-6.9.0.dist-info/METADATA,sha256=eVZTY6z46Bgtxy3p_6YtoAGXX7Mot6YfEdEKouixpew,6024
+posthoganalytics-6.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+posthoganalytics-6.9.0.dist-info/top_level.txt,sha256=8QsNIqIkBh1p2TXvKp0Em9ZLZKwe3uIqCETyW4s1GOE,17
+posthoganalytics-6.9.0.dist-info/RECORD,,