fix(flags): Add a shorter configurable timeout for flag requests (#120)

* chore(flags): Update type hints for newer mypy versions

* black

CHANGELOG.md

@@ -1,3 +1,40 @@
+## 3.5.0 - 2024-02-29
+
+1. - Adds a new `feature_flags_request_timeout_seconds` timeout parameter for feature flags which defaults to 3 seconds, updated from the default 10s for all other API calls.
+
+## 3.4.2 - 2024-02-20
+
+1. Add `historical_migration` option for bulk migration to PostHog Cloud.
+
+## 3.4.1 - 2024-02-09
+
+1. Use new hosts for event capture as well
+
+## 3.4.0 - 2024-02-05
+
+1. Point given hosts to new ingestion hosts
+
+## 3.3.4 - 2024-01-30
+
+1. Update type hints for module variables to work with newer versions of mypy
+
+## 3.3.3 - 2024-01-26
+
+1. Remove new relative date operators, combine into regular date operators
+
+## 3.3.2 - 2024-01-19
+
+1. Return success/failure with all capture calls from module functions
+
+
+## 3.3.1 - 2024-01-10
+
+1. Make sure we don't override any existing feature flag properties when adding locally evaluated feature flag properties.
+
+## 3.3.0 - 2024-01-09
+
+1. When local evaluation is enabled, we automatically add flag information to all events sent to PostHog, whenever possible. This makes it easier to use these events in experiments.
+
 ## 3.2.0 - 2024-01-09
 
 1. Numeric property handling for feature flags now does the expected: When passed in a number, we do a numeric comparison. When passed in a string, we do a string comparison. Previously, we always did a string comparison.
@@ -94,7 +131,7 @@ Changes:
 Breaking changes:
 
 1. The minimum version requirement for PostHog servers is now 1.38. If you're using PostHog Cloud, you satisfy this requirement automatically.
-2. Feature flag defaults apply only when there's an error fetching feature flag results. Earlier, if the default was set to `True`, even if a flag resolved to `False`, the default would override this. 
+2. Feature flag defaults apply only when there's an error fetching feature flag results. Earlier, if the default was set to `True`, even if a flag resolved to `False`, the default would override this.
 **Note: These are removed in 2.0.2**
 3. Feature flag remote evaluation doesn't require a personal API key.
 

posthog/__init__.py

@@ -1,5 +1,5 @@
 import datetime  # noqa: F401
-from typing import Callable, Dict, Optional  # noqa: F401
+from typing import Callable, Dict, Optional, Tuple  # noqa: F401
 
 from posthog.client import Client
 from posthog.version import VERSION
@@ -7,19 +7,20 @@ from posthog.version import VERSION
 __version__ = VERSION
 
 """Settings."""
-api_key = None  # type: str
-host = None  # type: str
-on_error = None  # type: Callable
+api_key = None  # type: Optional[str]
+host = None  # type: Optional[str]
+on_error = None  # type: Optional[Callable]
 debug = False  # type: bool
 send = True  # type: bool
 sync_mode = False  # type: bool
 disabled = False  # type: bool
-personal_api_key = None  # type: str
-project_api_key = None  # type: str
+personal_api_key = None  # type: Optional[str]
+project_api_key = None  # type: Optional[str]
 poll_interval = 30  # type: int
 disable_geoip = True  # type: bool
+feature_flags_request_timeout_seconds = 3  # type: int
 
-default_client = None
+default_client = None  # type: Optional[Client]
 
 
 def capture(
@@ -33,7 +34,7 @@ def capture(
     send_feature_flags=False,
     disable_geoip=None,  # type: Optional[bool]
 ):
-    # type: (...) -> None
+    # type: (...) -> Tuple[bool, dict]
     """
     Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up.
 
@@ -54,7 +55,7 @@ def capture(
     posthog.capture('distinct id', 'purchase', groups={'company': 'id:5'})
     ```
     """
-    _proxy(
+    return _proxy(
         "capture",
         distinct_id=distinct_id,
         event=event,
@@ -76,7 +77,7 @@ def identify(
     uuid=None,  # type: Optional[str]
     disable_geoip=None,  # type: Optional[bool]
 ):
-    # type: (...) -> None
+    # type: (...) -> Tuple[bool, dict]
     """
     Identify lets you add metadata on your users so you can more easily identify who they are in PostHog, and even do things like segment users by these properties.
 
@@ -92,7 +93,7 @@ def identify(
     })
     ```
     """
-    _proxy(
+    return _proxy(
         "identify",
         distinct_id=distinct_id,
         properties=properties,
@@ -111,7 +112,7 @@ def set(
     uuid=None,  # type: Optional[str]
     disable_geoip=None,  # type: Optional[bool]
 ):
-    # type: (...) -> None
+    # type: (...) -> Tuple[bool, dict]
     """
     Set properties on a user record.
     This will overwrite previous people property values, just like `identify`.
@@ -127,7 +128,7 @@ def set(
      })
      ```
     """
-    _proxy(
+    return _proxy(
         "set",
         distinct_id=distinct_id,
         properties=properties,
@@ -146,7 +147,7 @@ def set_once(
     uuid=None,  # type: Optional[str]
     disable_geoip=None,  # type: Optional[bool]
 ):
-    # type: (...) -> None
+    # type: (...) -> Tuple[bool, dict]
     """
     Set properties on a user record, only if they do not yet exist.
     This will not overwrite previous people property values, unlike `identify`.
@@ -162,7 +163,7 @@ def set_once(
      })
      ```
     """
-    _proxy(
+    return _proxy(
         "set_once",
         distinct_id=distinct_id,
         properties=properties,
@@ -182,7 +183,7 @@ def group_identify(
     uuid=None,  # type: Optional[str]
     disable_geoip=None,  # type: Optional[bool]
 ):
-    # type: (...) -> None
+    # type: (...) -> Tuple[bool, dict]
     """
     Set properties on a group
 
@@ -198,7 +199,7 @@ def group_identify(
      })
      ```
     """
-    _proxy(
+    return _proxy(
         "group_identify",
         group_type=group_type,
         group_key=group_key,
@@ -218,7 +219,7 @@ def alias(
     uuid=None,  # type: Optional[str]
     disable_geoip=None,  # type: Optional[bool]
 ):
-    # type: (...) -> None
+    # type: (...) -> Tuple[bool, dict]
     """
     To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like "Which marketing channels leads to users churning after a month?" or "What do users do on our website before signing up?"
 
@@ -235,7 +236,7 @@ def alias(
     posthog.alias('anonymous session id', 'distinct id')
     ```
     """
-    _proxy(
+    return _proxy(
         "alias",
         previous_id=previous_id,
         distinct_id=distinct_id,
@@ -405,6 +406,11 @@ def feature_flag_definitions():
     return _proxy("feature_flag_definitions")
 
 
+def load_feature_flags():
+    """Load feature flag definitions from PostHog."""
+    return _proxy("load_feature_flags")
+
+
 def page(*args, **kwargs):
     """Send a page call."""
     _proxy("page", *args, **kwargs)
@@ -447,6 +453,7 @@ def _proxy(method, *args, **kwargs):
             poll_interval=poll_interval,
             disabled=disabled,
             disable_geoip=disable_geoip,
+            feature_flags_request_timeout_seconds=feature_flags_request_timeout_seconds,
         )
 
     # always set incase user changes it

posthog/client.py

@@ -10,7 +10,7 @@ from six import string_types
 from posthog.consumer import Consumer
 from posthog.feature_flags import InconclusiveMatchError, match_feature_flag_properties
 from posthog.poller import Poller
-from posthog.request import APIError, batch_post, decide, get
+from posthog.request import APIError, batch_post, decide, determine_server_host, get
 from posthog.utils import SizeLimitedDict, clean, guess_timezone
 from posthog.version import VERSION
 
@@ -49,6 +49,8 @@ class Client(object):
         project_api_key=None,
         disabled=False,
         disable_geoip=True,
+        historical_migration=False,
+        feature_flags_request_timeout_seconds=3,
     ):
         self.queue = queue.Queue(max_queue_size)
 
@@ -61,7 +63,7 @@ class Client(object):
         self.debug = debug
         self.send = send
         self.sync_mode = sync_mode
-        self.host = host
+        self.host = determine_server_host(host)
         self.gzip = gzip
         self.timeout = timeout
         self.feature_flags = None
@@ -69,10 +71,12 @@ class Client(object):
         self.group_type_mapping = None
         self.cohorts = None
         self.poll_interval = poll_interval
+        self.feature_flags_request_timeout_seconds = feature_flags_request_timeout_seconds
         self.poller = None
         self.distinct_ids_feature_flags_reported = SizeLimitedDict(MAX_DICT_SIZE, set)
         self.disabled = disabled
         self.disable_geoip = disable_geoip
+        self.historical_migration = historical_migration
 
         # personal_api_key: This should be a generated Personal API Key, private
         self.personal_api_key = personal_api_key
@@ -100,13 +104,14 @@ class Client(object):
                 consumer = Consumer(
                     self.queue,
                     self.api_key,
-                    host=host,
+                    host=self.host,
                     on_error=on_error,
                     flush_at=flush_at,
                     flush_interval=flush_interval,
                     gzip=gzip,
                     retries=max_retries,
                     timeout=timeout,
+                    historical_migration=historical_migration,
                 )
                 self.consumers.append(consumer)
 
@@ -137,16 +142,6 @@ class Client(object):
         resp_data = self.get_decide(distinct_id, groups, person_properties, group_properties, disable_geoip)
         return resp_data["featureFlags"]
 
-    def _get_active_feature_variants(
-        self, distinct_id, groups=None, person_properties=None, group_properties=None, disable_geoip=None
-    ):
-        feature_variants = self.get_feature_variants(
-            distinct_id, groups, person_properties, group_properties, disable_geoip
-        )
-        return {
-            k: v for (k, v) in feature_variants.items() if v is not False
-        }  # explicitly test for false to account for values that may seem falsy (ex: 0)
-
     def get_feature_payloads(
         self, distinct_id, groups=None, person_properties=None, group_properties=None, disable_geoip=None
     ):
@@ -171,7 +166,7 @@ class Client(object):
             "group_properties": group_properties,
             "disable_geoip": disable_geoip,
         }
-        resp_data = decide(self.api_key, self.host, timeout=10, **request_data)
+        resp_data = decide(self.api_key, self.host, timeout=self.feature_flags_request_timeout_seconds, **request_data)
 
         return resp_data
 
@@ -206,15 +201,29 @@ class Client(object):
             require("groups", groups, dict)
             msg["properties"]["$groups"] = groups
 
+        extra_properties = {}
+        feature_variants = {}
         if send_feature_flags:
             try:
-                feature_variants = self._get_active_feature_variants(distinct_id, groups, disable_geoip=disable_geoip)
+                feature_variants = self.get_feature_variants(distinct_id, groups, disable_geoip=disable_geoip)
             except Exception as e:
                 self.log.exception(f"[FEATURE FLAGS] Unable to get feature variants: {e}")
-            else:
-                for feature, variant in feature_variants.items():
-                    msg["properties"]["$feature/{}".format(feature)] = variant
-                msg["properties"]["$active_feature_flags"] = list(feature_variants.keys())
+
+        elif self.feature_flags:
+            # Local evaluation is enabled, flags are loaded, so try and get all flags we can without going to the server
+            feature_variants = self.get_all_flags(
+                distinct_id, groups=(groups or {}), disable_geoip=disable_geoip, only_evaluate_locally=True
+            )
+
+        for feature, variant in feature_variants.items():
+            extra_properties[f"$feature/{feature}"] = variant
+
+        active_feature_flags = [key for (key, value) in feature_variants.items() if value is not False]
+        if active_feature_flags:
+            extra_properties["$active_feature_flags"] = active_feature_flags
+
+        if extra_properties:
+            msg["properties"] = {**extra_properties, **msg["properties"]}
 
         return self._enqueue(msg, disable_geoip)
 
@@ -370,7 +379,14 @@ class Client(object):
 
         if self.sync_mode:
             self.log.debug("enqueued with blocking %s.", msg["event"])
-            batch_post(self.api_key, self.host, gzip=self.gzip, timeout=self.timeout, batch=[msg])
+            batch_post(
+                self.api_key,
+                self.host,
+                gzip=self.gzip,
+                timeout=self.timeout,
+                batch=[msg],
+                historical_migration=self.historical_migration,
+            )
 
             return True, msg
 
@@ -460,7 +476,16 @@ class Client(object):
             self.poller = Poller(interval=timedelta(seconds=self.poll_interval), execute=self._load_feature_flags)
             self.poller.start()
 
-    def _compute_flag_locally(self, feature_flag, distinct_id, *, groups={}, person_properties={}, group_properties={}):
+    def _compute_flag_locally(
+        self,
+        feature_flag,
+        distinct_id,
+        *,
+        groups={},
+        person_properties={},
+        group_properties={},
+        warn_on_unknown_groups=True,
+    ):
         if feature_flag.get("ensure_experience_continuity", False):
             raise InconclusiveMatchError("Flag has experience continuity enabled")
 
@@ -482,9 +507,14 @@ class Client(object):
             if group_name not in groups:
                 # Group flags are never enabled in `groups` aren't passed in
                 # don't failover to `/decide/`, since response will be the same
-                self.log.warning(
-                    f"[FEATURE FLAGS] Can't compute group feature flag: {feature_flag['key']} without group names passed in"
-                )
+                if warn_on_unknown_groups:
+                    self.log.warning(
+                        f"[FEATURE FLAGS] Can't compute group feature flag: {feature_flag['key']} without group names passed in"
+                    )
+                else:
+                    self.log.debug(
+                        f"[FEATURE FLAGS] Can't compute group feature flag: {feature_flag['key']} without group names passed in"
+                    )
                 return False
 
             focused_group_properties = group_properties[group_name]
@@ -538,6 +568,10 @@ class Client(object):
         if self.disabled:
             return None
 
+        person_properties, group_properties = self._add_local_person_and_group_properties(
+            distinct_id, groups, person_properties, group_properties
+        )
+
         if self.feature_flags is None and self.personal_api_key:
             self.load_feature_flags()
         response = None
@@ -685,6 +719,10 @@ class Client(object):
         if self.disabled:
             return {"featureFlags": None, "featureFlagPayloads": None}
 
+        person_properties, group_properties = self._add_local_person_and_group_properties(
+            distinct_id, groups, person_properties, group_properties
+        )
+
         flags, payloads, fallback_to_decide = self._get_all_flags_and_payloads_locally(
             distinct_id, groups=groups, person_properties=person_properties, group_properties=group_properties
         )
@@ -705,7 +743,9 @@ class Client(object):
 
         return response
 
-    def _get_all_flags_and_payloads_locally(self, distinct_id, *, groups={}, person_properties={}, group_properties={}):
+    def _get_all_flags_and_payloads_locally(
+        self, distinct_id, *, groups={}, person_properties={}, group_properties={}, warn_on_unknown_groups=False
+    ):
         require("distinct_id", distinct_id, ID_TYPES)
         require("groups", groups, dict)
 
@@ -725,6 +765,7 @@ class Client(object):
                         groups=groups,
                         person_properties=person_properties,
                         group_properties=group_properties,
+                        warn_on_unknown_groups=warn_on_unknown_groups,
                     )
                     matched_payload = self._compute_payload_locally(flag["key"], flags[flag["key"]])
                     if matched_payload:
@@ -743,6 +784,19 @@ class Client(object):
     def feature_flag_definitions(self):
         return self.feature_flags
 
+    def _add_local_person_and_group_properties(self, distinct_id, groups, person_properties, group_properties):
+        all_person_properties = {"distinct_id": distinct_id, **(person_properties or {})}
+
+        all_group_properties = {}
+        if groups:
+            for group_name in groups:
+                all_group_properties[group_name] = {
+                    "$group_key": groups[group_name],
+                    **(group_properties.get(group_name) or {}),
+                }
+
+        return all_person_properties, all_group_properties
+
 
 def require(name, field, data_type):
     """Require that the named `field` has the right `data_type`"""

posthog/consumer.py

@@ -36,6 +36,7 @@ class Consumer(Thread):
         gzip=False,
         retries=10,
         timeout=15,
+        historical_migration=False,
     ):
         """Create a consumer thread."""
         Thread.__init__(self)
@@ -55,6 +56,7 @@ class Consumer(Thread):
         self.running = True
         self.retries = retries
         self.timeout = timeout
+        self.historical_migration = historical_migration
 
     def run(self):
         """Runs the consumer."""
@@ -134,6 +136,13 @@ class Consumer(Thread):
 
         @backoff.on_exception(backoff.expo, Exception, max_tries=self.retries + 1, giveup=fatal_exception)
         def send_request():
-            batch_post(self.api_key, self.host, gzip=self.gzip, timeout=self.timeout, batch=batch)
+            batch_post(
+                self.api_key,
+                self.host,
+                gzip=self.gzip,
+                timeout=self.timeout,
+                batch=batch,
+                historical_migration=self.historical_migration,
+            )
 
         send_request()

posthog/feature_flags.py

@@ -175,11 +175,11 @@ def match_property(property, property_values) -> bool:
         else:
             return compare(str(override_value), str(value), operator)
 
-    if operator in ["is_date_before", "is_date_after", "is_relative_date_before", "is_relative_date_after"]:
+    if operator in ["is_date_before", "is_date_after"]:
         try:
-            if operator in ["is_relative_date_before", "is_relative_date_after"]:
-                parsed_date = relative_date_parse_for_feature_flag_matching(str(value))
-            else:
+            parsed_date = relative_date_parse_for_feature_flag_matching(str(value))
+
+            if not parsed_date:
                 parsed_date = parser.parse(str(value))
                 parsed_date = convert_to_datetime_aware(parsed_date)
         except Exception as e:
@@ -190,12 +190,12 @@ def match_property(property, property_values) -> bool:
 
         if isinstance(override_value, datetime.datetime):
             override_date = convert_to_datetime_aware(override_value)
-            if operator in ("is_date_before", "is_relative_date_before"):
+            if operator == "is_date_before":
                 return override_date < parsed_date
             else:
                 return override_date > parsed_date
         elif isinstance(override_value, datetime.date):
-            if operator in ("is_date_before", "is_relative_date_before"):
+            if operator == "is_date_before":
                 return override_value < parsed_date.date()
             else:
                 return override_value > parsed_date.date()
@@ -203,7 +203,7 @@ def match_property(property, property_values) -> bool:
             try:
                 override_date = parser.parse(override_value)
                 override_date = convert_to_datetime_aware(override_date)
-                if operator in ("is_date_before", "is_relative_date_before"):
+                if operator == "is_date_before":
                     return override_date < parsed_date
                 else:
                     return override_date > parsed_date
@@ -302,7 +302,7 @@ def match_property_group(property_group, property_values, cohort_properties) ->
 
 
 def relative_date_parse_for_feature_flag_matching(value: str) -> Optional[datetime.datetime]:
-    regex = r"^(?P<number>[0-9]+)(?P<interval>[a-z])$"
+    regex = r"^-?(?P<number>[0-9]+)(?P<interval>[a-z])$"
     match = re.search(regex, value)
     parsed_dt = datetime.datetime.now(datetime.timezone.utc)
     if match:

posthog/request.py

@@ -13,10 +13,24 @@ from posthog.version import VERSION
 
 _session = requests.sessions.Session()
 
-DEFAULT_HOST = "https://app.posthog.com"
+US_INGESTION_ENDPOINT = "https://us-api.i.posthog.com"
+EU_INGESTION_ENDPOINT = "https://eu-api.i.posthog.com"
+DEFAULT_HOST = US_INGESTION_ENDPOINT
 USER_AGENT = "posthog-python/" + VERSION
 
 
+def determine_server_host(host: Optional[str]) -> str:
+    """Determines the server host to use."""
+    host_or_default = host or DEFAULT_HOST
+    trimmed_host = remove_trailing_slash(host_or_default)
+    if trimmed_host in ("https://app.posthog.com", "https://us.posthog.com"):
+        return US_INGESTION_ENDPOINT
+    elif trimmed_host == "https://eu.posthog.com":
+        return EU_INGESTION_ENDPOINT
+    else:
+        return host_or_default
+
+
 def post(
     api_key: str, host: Optional[str] = None, path=None, gzip: bool = False, timeout: int = 15, **kwargs
 ) -> requests.Response:

posthog/sentry/posthog_integration.py

@@ -43,9 +43,9 @@ class PostHogIntegration(Integration):
                             not not Hub.current.client.dsn and Dsn(Hub.current.client.dsn).project_id
                         )
                         if project_id:
-                            properties[
-                                "$sentry_url"
-                            ] = f"{PostHogIntegration.prefix}{PostHogIntegration.organization}/issues/?project={project_id}&query={event['event_id']}"
+                            properties["$sentry_url"] = (
+                                f"{PostHogIntegration.prefix}{PostHogIntegration.organization}/issues/?project={project_id}&query={event['event_id']}"
+                            )
 
                     posthog.capture(posthog_distinct_id, "$exception", properties)
 

posthog/test/test_client.py

@@ -106,24 +106,187 @@ class TestClient(unittest.TestCase):
         self.assertEqual(patch_decide.call_count, 1)
 
     @mock.patch("posthog.client.decide")
-    def test_get_active_feature_flags(self, patch_decide):
-        patch_decide.return_value = {
-            "featureFlags": {"beta-feature": "random-variant", "alpha-feature": True, "off-feature": False}
-        }
-
+    def test_basic_capture_with_locally_evaluated_feature_flags(self, patch_decide):
+        patch_decide.return_value = {"featureFlags": {"beta-feature": "random-variant"}}
         client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, personal_api_key=FAKE_TEST_API_KEY)
-        variants = client._get_active_feature_variants("some_id", None, None, None, False)
-        self.assertEqual(variants, {"beta-feature": "random-variant", "alpha-feature": True})
-        patch_decide.assert_called_with(
-            "random_key",
-            None,
-            timeout=10,
-            distinct_id="some_id",
-            groups={},
-            person_properties=None,
-            group_properties=None,
-            disable_geoip=False,
+
+        multivariate_flag = {
+            "id": 1,
+            "name": "Beta Feature",
+            "key": "beta-feature-local",
+            "is_simple_flag": False,
+            "active": True,
+            "rollout_percentage": 100,
+            "filters": {
+                "groups": [
+                    {
+                        "properties": [
+                            {"key": "email", "type": "person", "value": "test@posthog.com", "operator": "exact"}
+                        ],
+                        "rollout_percentage": 100,
+                    },
+                    {
+                        "rollout_percentage": 50,
+                    },
+                ],
+                "multivariate": {
+                    "variants": [
+                        {"key": "first-variant", "name": "First Variant", "rollout_percentage": 50},
+                        {"key": "second-variant", "name": "Second Variant", "rollout_percentage": 25},
+                        {"key": "third-variant", "name": "Third Variant", "rollout_percentage": 25},
+                    ]
+                },
+                "payloads": {"first-variant": "some-payload", "third-variant": {"a": "json"}},
+            },
+        }
+        basic_flag = {
+            "id": 1,
+            "name": "Beta Feature",
+            "key": "person-flag",
+            "is_simple_flag": True,
+            "active": True,
+            "filters": {
+                "groups": [
+                    {
+                        "properties": [
+                            {
+                                "key": "region",
+                                "operator": "exact",
+                                "value": ["USA"],
+                                "type": "person",
+                            }
+                        ],
+                        "rollout_percentage": 100,
+                    }
+                ],
+                "payloads": {"true": 300},
+            },
+        }
+        false_flag = {
+            "id": 1,
+            "name": "Beta Feature",
+            "key": "false-flag",
+            "is_simple_flag": True,
+            "active": True,
+            "filters": {
+                "groups": [
+                    {
+                        "properties": [],
+                        "rollout_percentage": 0,
+                    }
+                ],
+                "payloads": {"true": 300},
+            },
+        }
+        client.feature_flags = [multivariate_flag, basic_flag, false_flag]
+
+        success, msg = client.capture("distinct_id", "python test event")
+        client.flush()
+        self.assertTrue(success)
+        self.assertFalse(self.failed)
+
+        self.assertEqual(msg["event"], "python test event")
+        self.assertTrue(isinstance(msg["timestamp"], str))
+        self.assertIsNone(msg.get("uuid"))
+        self.assertEqual(msg["distinct_id"], "distinct_id")
+        self.assertEqual(msg["properties"]["$lib"], "posthog-python")
+        self.assertEqual(msg["properties"]["$lib_version"], VERSION)
+        self.assertEqual(msg["properties"]["$feature/beta-feature-local"], "third-variant")
+        self.assertEqual(msg["properties"]["$feature/false-flag"], False)
+        self.assertEqual(msg["properties"]["$active_feature_flags"], ["beta-feature-local"])
+        assert "$feature/beta-feature" not in msg["properties"]
+
+        self.assertEqual(patch_decide.call_count, 0)
+
+        # test that flags are not evaluated without local evaluation
+        client.feature_flags = []
+        success, msg = client.capture("distinct_id", "python test event")
+        client.flush()
+        self.assertTrue(success)
+        self.assertFalse(self.failed)
+        assert "$feature/beta-feature" not in msg["properties"]
+        assert "$feature/beta-feature-local" not in msg["properties"]
+        assert "$feature/false-flag" not in msg["properties"]
+        assert "$active_feature_flags" not in msg["properties"]
+
+    @mock.patch("posthog.client.decide")
+    def test_dont_override_capture_with_local_flags(self, patch_decide):
+        patch_decide.return_value = {"featureFlags": {"beta-feature": "random-variant"}}
+        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, personal_api_key=FAKE_TEST_API_KEY)
+
+        multivariate_flag = {
+            "id": 1,
+            "name": "Beta Feature",
+            "key": "beta-feature-local",
+            "is_simple_flag": False,
+            "active": True,
+            "rollout_percentage": 100,
+            "filters": {
+                "groups": [
+                    {
+                        "properties": [
+                            {"key": "email", "type": "person", "value": "test@posthog.com", "operator": "exact"}
+                        ],
+                        "rollout_percentage": 100,
+                    },
+                    {
+                        "rollout_percentage": 50,
+                    },
+                ],
+                "multivariate": {
+                    "variants": [
+                        {"key": "first-variant", "name": "First Variant", "rollout_percentage": 50},
+                        {"key": "second-variant", "name": "Second Variant", "rollout_percentage": 25},
+                        {"key": "third-variant", "name": "Third Variant", "rollout_percentage": 25},
+                    ]
+                },
+                "payloads": {"first-variant": "some-payload", "third-variant": {"a": "json"}},
+            },
+        }
+        basic_flag = {
+            "id": 1,
+            "name": "Beta Feature",
+            "key": "person-flag",
+            "is_simple_flag": True,
+            "active": True,
+            "filters": {
+                "groups": [
+                    {
+                        "properties": [
+                            {
+                                "key": "region",
+                                "operator": "exact",
+                                "value": ["USA"],
+                                "type": "person",
+                            }
+                        ],
+                        "rollout_percentage": 100,
+                    }
+                ],
+                "payloads": {"true": 300},
+            },
+        }
+        client.feature_flags = [multivariate_flag, basic_flag]
+
+        success, msg = client.capture(
+            "distinct_id", "python test event", {"$feature/beta-feature-local": "my-custom-variant"}
         )
+        client.flush()
+        self.assertTrue(success)
+        self.assertFalse(self.failed)
+
+        self.assertEqual(msg["event"], "python test event")
+        self.assertTrue(isinstance(msg["timestamp"], str))
+        self.assertIsNone(msg.get("uuid"))
+        self.assertEqual(msg["distinct_id"], "distinct_id")
+        self.assertEqual(msg["properties"]["$lib"], "posthog-python")
+        self.assertEqual(msg["properties"]["$lib_version"], VERSION)
+        self.assertEqual(msg["properties"]["$feature/beta-feature-local"], "my-custom-variant")
+        self.assertEqual(msg["properties"]["$active_feature_flags"], ["beta-feature-local"])
+        assert "$feature/beta-feature" not in msg["properties"]
+        assert "$feature/person-flag" not in msg["properties"]
+
+        self.assertEqual(patch_decide.call_count, 0)
 
     @mock.patch("posthog.client.decide")
     def test_basic_capture_with_feature_flags_returns_active_only(self, patch_decide):
@@ -151,8 +314,8 @@ class TestClient(unittest.TestCase):
         self.assertEqual(patch_decide.call_count, 1)
         patch_decide.assert_called_with(
             "random_key",
-            None,
-            timeout=10,
+            "https://us-api.i.posthog.com",
+            timeout=3,
             distinct_id="distinct_id",
             groups={},
             person_properties=None,
@@ -167,7 +330,12 @@ class TestClient(unittest.TestCase):
         }
 
         client = Client(
-            FAKE_TEST_API_KEY, on_error=self.set_fail, personal_api_key=FAKE_TEST_API_KEY, disable_geoip=True
+            FAKE_TEST_API_KEY,
+            host="https://app.posthog.com",
+            on_error=self.set_fail,
+            personal_api_key=FAKE_TEST_API_KEY,
+            disable_geoip=True,
+            feature_flags_request_timeout_seconds=12,
         )
         success, msg = client.capture("distinct_id", "python test event", send_feature_flags=True, disable_geoip=False)
         client.flush()
@@ -188,8 +356,8 @@ class TestClient(unittest.TestCase):
         self.assertEqual(patch_decide.call_count, 1)
         patch_decide.assert_called_with(
             "random_key",
-            None,
-            timeout=10,
+            "https://us-api.i.posthog.com",
+            timeout=12,
             distinct_id="distinct_id",
             groups={},
             person_properties=None,
@@ -616,11 +784,11 @@ class TestClient(unittest.TestCase):
         client.get_feature_flag("random_key", "some_id", disable_geoip=True)
         patch_decide.assert_called_with(
             "random_key",
-            None,
-            timeout=10,
+            "https://us-api.i.posthog.com",
+            timeout=3,
             distinct_id="some_id",
             groups={},
-            person_properties={},
+            person_properties={"distinct_id": "some_id"},
             group_properties={},
             disable_geoip=True,
         )
@@ -628,11 +796,11 @@ class TestClient(unittest.TestCase):
         client.feature_enabled("random_key", "feature_enabled_distinct_id", disable_geoip=True)
         patch_decide.assert_called_with(
             "random_key",
-            None,
-            timeout=10,
+            "https://us-api.i.posthog.com",
+            timeout=3,
             distinct_id="feature_enabled_distinct_id",
             groups={},
-            person_properties={},
+            person_properties={"distinct_id": "feature_enabled_distinct_id"},
             group_properties={},
             disable_geoip=True,
         )
@@ -640,11 +808,11 @@ class TestClient(unittest.TestCase):
         client.get_all_flags_and_payloads("all_flags_payloads_id")
         patch_decide.assert_called_with(
             "random_key",
-            None,
-            timeout=10,
+            "https://us-api.i.posthog.com",
+            timeout=3,
             distinct_id="all_flags_payloads_id",
             groups={},
-            person_properties={},
+            person_properties={"distinct_id": "all_flags_payloads_id"},
             group_properties={},
             disable_geoip=False,
         )
@@ -660,3 +828,70 @@ class TestClient(unittest.TestCase):
         client.feature_flags = [{"key": "example", "is_simple_flag": False}]
 
         self.assertFalse(client.feature_enabled("example", "distinct_id"))
+
+    @mock.patch("posthog.client.decide")
+    def test_default_properties_get_added_properly(self, patch_decide):
+        patch_decide.return_value = {
+            "featureFlags": {"beta-feature": "random-variant", "alpha-feature": True, "off-feature": False}
+        }
+        client = Client(FAKE_TEST_API_KEY, host="http://app2.posthog.com", on_error=self.set_fail, disable_geoip=False)
+        client.get_feature_flag(
+            "random_key",
+            "some_id",
+            groups={"company": "id:5", "instance": "app.posthog.com"},
+            person_properties={"x1": "y1"},
+            group_properties={"company": {"x": "y"}},
+        )
+        patch_decide.assert_called_with(
+            "random_key",
+            "http://app2.posthog.com",
+            timeout=3,
+            distinct_id="some_id",
+            groups={"company": "id:5", "instance": "app.posthog.com"},
+            person_properties={"distinct_id": "some_id", "x1": "y1"},
+            group_properties={
+                "company": {"$group_key": "id:5", "x": "y"},
+                "instance": {"$group_key": "app.posthog.com"},
+            },
+            disable_geoip=False,
+        )
+
+        patch_decide.reset_mock()
+        client.get_feature_flag(
+            "random_key",
+            "some_id",
+            groups={"company": "id:5", "instance": "app.posthog.com"},
+            person_properties={"distinct_id": "override"},
+            group_properties={
+                "company": {
+                    "$group_key": "group_override",
+                }
+            },
+        )
+        patch_decide.assert_called_with(
+            "random_key",
+            "http://app2.posthog.com",
+            timeout=3,
+            distinct_id="some_id",
+            groups={"company": "id:5", "instance": "app.posthog.com"},
+            person_properties={"distinct_id": "override"},
+            group_properties={
+                "company": {"$group_key": "group_override"},
+                "instance": {"$group_key": "app.posthog.com"},
+            },
+            disable_geoip=False,
+        )
+
+        patch_decide.reset_mock()
+        # test nones
+        client.get_all_flags_and_payloads("some_id", groups={}, person_properties=None, group_properties=None)
+        patch_decide.assert_called_with(
+            "random_key",
+            "http://app2.posthog.com",
+            timeout=3,
+            distinct_id="some_id",
+            groups={},
+            person_properties={"distinct_id": "some_id"},
+            group_properties={},
+            disable_geoip=False,
+        )

posthog/test/test_feature_flags.py

@@ -1873,7 +1873,7 @@ class TestMatchProperties(unittest.TestCase):
 
     @freeze_time("2022-05-01")
     def test_match_property_relative_date_operators(self):
-        property_a = self.property(key="key", value="6h", operator="is_relative_date_before")
+        property_a = self.property(key="key", value="-6h", operator="is_date_before")
         self.assertTrue(match_property(property_a, {"key": "2022-03-01"}))
         self.assertTrue(match_property(property_a, {"key": "2022-04-30"}))
         self.assertTrue(match_property(property_a, {"key": datetime.datetime(2022, 4, 30, 1, 2, 3)}))
@@ -1898,7 +1898,7 @@ class TestMatchProperties(unittest.TestCase):
         with self.assertRaises(InconclusiveMatchError):
             match_property(property_a, {"key": "abcdef"})
 
-        property_b = self.property(key="key", value="1h", operator="is_relative_date_after")
+        property_b = self.property(key="key", value="1h", operator="is_date_after")
         self.assertTrue(match_property(property_b, {"key": "2022-05-02"}))
         self.assertTrue(match_property(property_b, {"key": "2022-05-30"}))
         self.assertTrue(match_property(property_b, {"key": datetime.datetime(2022, 5, 30)}))
@@ -1910,16 +1910,16 @@ class TestMatchProperties(unittest.TestCase):
             self.assertFalse(match_property(property_b, {"key": "abcdef"}))
 
         # Invalid flag property
-        property_c = self.property(key="key", value=1234, operator="is_relative_date_after")
+        property_c = self.property(key="key", value=1234, operator="is_date_after")
 
         with self.assertRaises(InconclusiveMatchError):
             self.assertFalse(match_property(property_c, {"key": 1}))
 
-        with self.assertRaises(InconclusiveMatchError):
-            self.assertFalse(match_property(property_c, {"key": "2022-05-30"}))
+        # parsed as 1234-05-01 for some reason?
+        self.assertTrue(match_property(property_c, {"key": "2022-05-30"}))
 
         # # Timezone aware property
-        property_d = self.property(key="key", value="12d", operator="is_relative_date_before")
+        property_d = self.property(key="key", value="12d", operator="is_date_before")
         self.assertFalse(match_property(property_d, {"key": "2022-05-30"}))
 
         self.assertTrue(match_property(property_d, {"key": "2022-03-30"}))
@@ -1929,45 +1929,45 @@ class TestMatchProperties(unittest.TestCase):
         self.assertFalse(match_property(property_d, {"key": "2022-04-19 02:00:01+02:00"}))
 
         # Try all possible relative dates
-        property_e = self.property(key="key", value="1h", operator="is_relative_date_before")
+        property_e = self.property(key="key", value="1h", operator="is_date_before")
         self.assertFalse(match_property(property_e, {"key": "2022-05-01 00:00:00"}))
         self.assertTrue(match_property(property_e, {"key": "2022-04-30 22:00:00"}))
 
-        property_f = self.property(key="key", value="1d", operator="is_relative_date_before")
+        property_f = self.property(key="key", value="-1d", operator="is_date_before")
         self.assertTrue(match_property(property_f, {"key": "2022-04-29 23:59:00"}))
         self.assertFalse(match_property(property_f, {"key": "2022-04-30 00:00:01"}))
 
-        property_g = self.property(key="key", value="1w", operator="is_relative_date_before")
+        property_g = self.property(key="key", value="1w", operator="is_date_before")
         self.assertTrue(match_property(property_g, {"key": "2022-04-23 00:00:00"}))
         self.assertFalse(match_property(property_g, {"key": "2022-04-24 00:00:00"}))
         self.assertFalse(match_property(property_g, {"key": "2022-04-24 00:00:01"}))
 
-        property_h = self.property(key="key", value="1m", operator="is_relative_date_before")
+        property_h = self.property(key="key", value="1m", operator="is_date_before")
         self.assertTrue(match_property(property_h, {"key": "2022-03-01 00:00:00"}))
         self.assertFalse(match_property(property_h, {"key": "2022-04-05 00:00:00"}))
 
-        property_i = self.property(key="key", value="1y", operator="is_relative_date_before")
+        property_i = self.property(key="key", value="1y", operator="is_date_before")
         self.assertTrue(match_property(property_i, {"key": "2021-04-28 00:00:00"}))
         self.assertFalse(match_property(property_i, {"key": "2021-05-01 00:00:01"}))
 
-        property_j = self.property(key="key", value="122h", operator="is_relative_date_after")
+        property_j = self.property(key="key", value="122h", operator="is_date_after")
         self.assertTrue(match_property(property_j, {"key": "2022-05-01 00:00:00"}))
         self.assertFalse(match_property(property_j, {"key": "2022-04-23 01:00:00"}))
 
-        property_k = self.property(key="key", value="2d", operator="is_relative_date_after")
+        property_k = self.property(key="key", value="2d", operator="is_date_after")
         self.assertTrue(match_property(property_k, {"key": "2022-05-01 00:00:00"}))
         self.assertTrue(match_property(property_k, {"key": "2022-04-29 00:00:01"}))
         self.assertFalse(match_property(property_k, {"key": "2022-04-29 00:00:00"}))
 
-        property_l = self.property(key="key", value="02w", operator="is_relative_date_after")
+        property_l = self.property(key="key", value="-02w", operator="is_date_after")
         self.assertTrue(match_property(property_l, {"key": "2022-05-01 00:00:00"}))
         self.assertFalse(match_property(property_l, {"key": "2022-04-16 00:00:00"}))
 
-        property_m = self.property(key="key", value="1m", operator="is_relative_date_after")
+        property_m = self.property(key="key", value="1m", operator="is_date_after")
         self.assertTrue(match_property(property_m, {"key": "2022-04-01 00:00:01"}))
         self.assertFalse(match_property(property_m, {"key": "2022-04-01 00:00:00"}))
 
-        property_n = self.property(key="key", value="1y", operator="is_relative_date_after")
+        property_n = self.property(key="key", value="1y", operator="is_date_after")
         self.assertTrue(match_property(property_n, {"key": "2022-05-01 00:00:00"}))
         self.assertTrue(match_property(property_n, {"key": "2021-05-01 00:00:01"}))
         self.assertFalse(match_property(property_n, {"key": "2021-05-01 00:00:00"}))

posthog/test/test_module.py

@@ -6,6 +6,10 @@ from posthog import Posthog
 class TestModule(unittest.TestCase):
     posthog = None
 
+    def _assert_enqueue_result(self, result):
+        self.assertEqual(type(result[0]), bool)
+        self.assertEqual(type(result[1]), dict)
+
     def failed(self):
         self.failed = True
 
@@ -22,15 +26,18 @@ class TestModule(unittest.TestCase):
         self.assertRaises(Exception, self.posthog.capture)
 
     def test_track(self):
-        self.posthog.capture("distinct_id", "python module event")
+        res = self.posthog.capture("distinct_id", "python module event")
+        self._assert_enqueue_result(res)
         self.posthog.flush()
 
     def test_identify(self):
-        self.posthog.identify("distinct_id", {"email": "user@email.com"})
+        res = self.posthog.identify("distinct_id", {"email": "user@email.com"})
+        self._assert_enqueue_result(res)
         self.posthog.flush()
 
     def test_alias(self):
-        self.posthog.alias("previousId", "distinct_id")
+        res = self.posthog.alias("previousId", "distinct_id")
+        self._assert_enqueue_result(res)
         self.posthog.flush()
 
     def test_page(self):

posthog/test/test_request.py

@@ -2,9 +2,10 @@ import json
 import unittest
 from datetime import date, datetime
 
+import pytest
 import requests
 
-from posthog.request import DatetimeSerializer, batch_post
+from posthog.request import DatetimeSerializer, batch_post, determine_server_host
 from posthog.test.test_utils import TEST_API_KEY
 
 
@@ -42,3 +43,26 @@ class TestRequests(unittest.TestCase):
             batch_post(
                 "key", batch=[{"distinct_id": "distinct_id", "event": "python event", "type": "track"}], timeout=0.0001
             )
+
+
+@pytest.mark.parametrize(
+    "host, expected",
+    [
+        ("https://t.posthog.com", "https://t.posthog.com"),
+        ("https://t.posthog.com/", "https://t.posthog.com/"),
+        ("t.posthog.com", "t.posthog.com"),
+        ("t.posthog.com/", "t.posthog.com/"),
+        ("https://us.posthog.com.rg.proxy.com", "https://us.posthog.com.rg.proxy.com"),
+        ("app.posthog.com", "app.posthog.com"),
+        ("eu.posthog.com", "eu.posthog.com"),
+        ("https://app.posthog.com", "https://us-api.i.posthog.com"),
+        ("https://eu.posthog.com", "https://eu-api.i.posthog.com"),
+        ("https://us.posthog.com", "https://us-api.i.posthog.com"),
+        ("https://app.posthog.com/", "https://us-api.i.posthog.com"),
+        ("https://eu.posthog.com/", "https://eu-api.i.posthog.com"),
+        ("https://us.posthog.com/", "https://us-api.i.posthog.com"),
+        (None, "https://us-api.i.posthog.com"),
+    ],
+)
+def test_routing_to_custom_host(host, expected):
+    assert determine_server_host(host) == expected

posthog/version.py

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

sentry_django_example/sentry_django_example/urls.py

@@ -13,6 +13,7 @@ Including another URLconf
     1. Import the include() function: from django.urls import include, path
     2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
 """
+
 from django.contrib import admin
 from django.urls import path