Bump version to 2.0.0 and add breaking changes changelog (#69)

* get feature flag method

* remove groups param from method

* use personal api key

* add groups

* add capture

* black reformat

* black?

* Update posthog/client.py

Co-authored-by: Neil Kakkar <neilkakkar@gmail.com>

* add to init

* formatting

Co-authored-by: Neil Kakkar <neilkakkar@gmail.com>

.github/workflows/release.yaml

@@ -0,0 +1,38 @@
+name: 'Release'
+
+on:
+  - workflow_dispatch
+
+jobs:
+    release:
+        name: Publish release
+        runs-on: ubuntu-20.04
+        env:
+            TWINE_USERNAME: __token__
+            TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        steps:
+            - name: Checkout the repository
+              uses: actions/checkout@v2
+              with:
+                  fetch-depth: 0
+                  token: ${{ secrets.POSTHOG_BOT_GITHUB_TOKEN }}
+
+            - name: Set up Python
+              uses: actions/setup-python@v2
+
+            - name: Detect version
+              run: echo "REPO_VERSION=$(python3 posthog/version.py)" >> $GITHUB_ENV
+
+            - name: Prepare for building release
+              run: pip install -U pip setuptools wheel twine
+
+            - name: Push release to PyPI
+              run: make release && make release_analytics
+
+            - name: Create GitHub release
+              uses: actions/create-release@v1
+              env:
+                  GITHUB_TOKEN: ${{ secrets.POSTHOG_BOT_GITHUB_TOKEN }}
+              with:
+                  tag_name: v${{ env.REPO_VERSION }}
+                  release_name: ${{ env.REPO_VERSION }}

CHANGELOG.md

@@ -1,15 +1,42 @@
-## 1.4.0 - 2021-05-07
+## 2.0.0 - 2022-08-02
 
-- Add support for project_api_key (#32)
+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.
+3. Feature flag remote evaluation doesn't require a personal API key.
+
+New Changes:
+
+1. You can now evaluate feature flags locally (i.e. without sending a request to your PostHog servers) by setting a personal API key, and passing in groups and person properties to `is_feature_enabled` and `get_feature_flag` calls.
+2. Introduces a `get_all_flags` method that returns all feature flags. This is useful for when you want to seed your frontend with some initial flags, given a user ID.
+
+
+
+## 1.4.9 - 2022-06-13
+- Support for sending feature flags with capture calls
+
+## 1.4.8 - 2022-05-12
+- Support multi variate feature flags
+
+## 1.4.7 - 2022-04-25
+- Allow feature flags usage without project_api_key
+
+## 1.4.1 - 2021-05-28
+- Fix packaging issues with Sentry integrations
+
+## 1.4.0 - 2021-05-18
+
+- Improve support for `project_api_key` (#32)
 - Resolve polling issues with feature flags (#29)
-- Add python sentry (and sentry & django) integrations (#13)
-- Fix feature flag issue with no % rollout (#30)
+- Add Sentry (and Sentry+Django) integrations (#13)
+- Fix feature flag issue with no percentage rollout (#30)
 
 ## 1.3.1 - 2021-05-07
 
-- Add $set and $set_once support (#23)
-- Add distinct id to $create_alias event (#27)
-- Add UUID to ID_TYPES (#26)
+- Add `$set` and `$set_once` support (#23)
+- Add distinct ID to `$create_alias` event (#27)
+- Add `UUID` to `ID_TYPES` (#26)
 
 ## 1.2.1 - 2021-02-05
 

README.md

@@ -1,27 +1,25 @@
 # PostHog Python
 
-Please see the main [PostHog docs](https://posthog.com/docs).
+[![PyPI](https://img.shields.io/pypi/v/posthog)](https://pypi.org/project/posthog/)
 
-Specifically, the [Python integration](https://posthog.com/docs/integrations/python-integration) details.
 
-## Questions?
+Please see the [Python integration docs](https://posthog.com/docs/integrations/python-integration) for details.
 
-### [Join our Slack community.](https://join.slack.com/t/posthogusers/shared_invite/enQtOTY0MzU5NjAwMDY3LTc2MWQ0OTZlNjhkODk3ZDI3NDVjMDE1YjgxY2I4ZjI4MzJhZmVmNjJkN2NmMGJmMzc2N2U3Yjc3ZjI5NGFlZDQ)
+## Development
 
-# Local Development
-
-## Testing Locally
+### Testing Locally
 
 1. Run `python3 -m venv env` (creates virtual environment called "env")
 2. Run `source env/bin/activate` (activates the virtual environment)
 3. Run `python3 -m pip install -e ".[test]"` (installs the package in develop mode, along with test dependencies)
 4. Run `make test`
+  1. To run a specific test do `pytest -k test_no_api_key`
 
-## Running Locally
+### Running Locally
 
 Assuming you have a [local version of PostHog](https://posthog.com/docs/developing-locally) running, you can run `python3 example.py` to see the library in action.
 
-## Running the Django Sentry Integration Locally
+### Running the Django Sentry Integration Locally
 
 There's a sample Django project included, called `sentry_django_example`, which explains how to use PostHog with Sentry.
 
@@ -38,3 +36,11 @@ There's 2 places of importance (Changes required are all marked with TODO in the
 To run things: `make django_example`. This installs the posthog-python library with the sentry-sdk add-on, and then runs the django app.
 Also start the PostHog app locally.
 Then navigate to `http://127.0.0.1:8080/sentry-debug/` and you should get an event in both Sentry and PostHog, with links to each other.
+
+### Releasing Versions
+
+Updated are released using GitHub Actions: after bumping `version.py` in `master`, go to [our release workflow's page](https://github.com/PostHog/posthog-python/actions/workflows/release.yaml) and dispatch it manually, using workflow from `master`.
+
+## Questions?
+
+### [Join our Slack community.](https://join.slack.com/t/posthogusers/shared_invite/enQtOTY0MzU5NjAwMDY3LTc2MWQ0OTZlNjhkODk3ZDI3NDVjMDE1YjgxY2I4ZjI4MzJhZmVmNjJkN2NmMGJmMzc2N2U3Yjc3ZjI5NGFlZDQ)

example.py

@@ -5,21 +5,24 @@ import time
 
 import posthog
 
+# posthog.debug = True
+
 # You can find this key on the /setup page in PostHog
 posthog.project_api_key = ""
 posthog.personal_api_key = ""
 
 # Where you host PostHog, with no trailing /.
 # You can remove this line if you're using posthog.com
-posthog.host = "http://127.0.0.1:8000"
+posthog.host = "http://localhost:8000"
 
 # Capture an event
-posthog.capture("distinct_id", "event", {"property1": "value", "property2": "value"})
+posthog.capture("distinct_id", "event", {"property1": "value", "property2": "value"}, send_feature_flags=True)
 
 print(posthog.feature_enabled("beta-feature", "distinct_id"))
+print(posthog.feature_enabled("beta-feature", "distinct_id", groups={"company": "id:5"}))
 
 print("sleeping")
-time.sleep(5)
+# time.sleep(5)
 
 print(posthog.feature_enabled("beta-feature", "distinct_id"))
 
@@ -28,14 +31,20 @@ print(posthog.feature_enabled("beta-feature", "distinct_id"))
 posthog.alias("distinct_id", "new_distinct_id")
 
 posthog.capture("new_distinct_id", "event2", {"property1": "value", "property2": "value"})
+posthog.capture(
+    "new_distinct_id", "event-with-groups", {"property1": "value", "property2": "value"}, groups={"company": "id:5"}
+)
 
 # # Add properties to the person
 posthog.identify("new_distinct_id", {"email": "something@something.com"})
 
+# Add properties to a group
+posthog.group_identify("company", "id:5", {"employees": 11})
+
 # properties set only once to the person
 posthog.set_once("new_distinct_id", {"self_serve_signup": True})
 
-time.sleep(3)
+# time.sleep(3)
 
 posthog.set_once(
     "new_distinct_id", {"self_serve_signup": False}
@@ -45,3 +54,13 @@ posthog.set("new_distinct_id", {"current_browser": "Chrome"})
 posthog.set("new_distinct_id", {"current_browser": "Firefox"})
 
 # posthog.shutdown()
+
+# #############################################################################
+# Make sure you have a personal API key for the examples below
+
+# Local Evaluation
+
+# If flag has City=Sydney, this call doesn't go to `/decide`
+print(posthog.feature_enabled("test-flag", "distinct_id_random_22", person_properties={"$geoip_city_name": "Sydney"}))
+
+print(posthog.get_all_flags("distinct_id_random_22"))

posthog/__init__.py

@@ -25,7 +25,9 @@ def capture(
     properties=None,  # type: Optional[Dict]
     context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
-    message_id=None,  # type: Optional[str]
+    uuid=None,  # type: Optional[str]
+    groups=None,  # type: Optional[Dict]
+    send_feature_flags=False,
 ):
     # type: (...) -> None
     """
@@ -38,10 +40,14 @@ def capture(
 
     Optionally you can submit
     - `properties`, which can be a dict with any information you'd like to add
+    - `groups`, which is a dict of group type -> group key mappings
 
     For example:
     ```python
+    posthog.capture('distinct id', 'opened app')
     posthog.capture('distinct id', 'movie played', {'movie_id': '123', 'category': 'romcom'})
+
+    posthog.capture('distinct id', 'purchase', groups={'company': 'id:5'})
     ```
     """
     _proxy(
@@ -51,16 +57,18 @@ def capture(
         properties=properties,
         context=context,
         timestamp=timestamp,
-        message_id=message_id,
+        uuid=uuid,
+        groups=groups,
+        send_feature_flags=send_feature_flags,
     )
 
 
 def identify(
-    distinct_id,  # type: str,
+    distinct_id,  # type: str
     properties=None,  # type: Optional[Dict]
     context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
-    message_id=None,  # type: Optional[str]
+    uuid=None,  # type: Optional[str]
 ):
     # type: (...) -> None
     """
@@ -84,7 +92,7 @@ def identify(
         properties=properties,
         context=context,
         timestamp=timestamp,
-        message_id=message_id,
+        uuid=uuid,
     )
 
 
@@ -93,7 +101,7 @@ def set(
     properties=None,  # type: Optional[Dict]
     context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
-    message_id=None,  # type: Optional[str]
+    uuid=None,  # type: Optional[str]
 ):
     # type: (...) -> None
     """
@@ -117,7 +125,7 @@ def set(
         properties=properties,
         context=context,
         timestamp=timestamp,
-        message_id=message_id,
+        uuid=uuid,
     )
 
 
@@ -126,7 +134,7 @@ def set_once(
     properties=None,  # type: Optional[Dict]
     context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
-    message_id=None,  # type: Optional[str]
+    uuid=None,  # type: Optional[str]
 ):
     # type: (...) -> None
     """
@@ -150,13 +158,43 @@ def set_once(
         properties=properties,
         context=context,
         timestamp=timestamp,
-        message_id=message_id,
+        uuid=uuid,
     )
 
 
-def group(*args, **kwargs):
-    """Send a group call."""
-    _proxy("group", *args, **kwargs)
+def group_identify(
+    group_type,  # type: str
+    group_key,  # type: str
+    properties=None,  # type: Optional[Dict]
+    context=None,  # type: Optional[Dict]
+    timestamp=None,  # type: Optional[datetime.datetime]
+    uuid=None,  # type: Optional[str]
+):
+    # type: (...) -> None
+    """
+    Set properties on a group
+
+     A `group_identify` call requires
+     - `group_type` type of your group
+     - `group_key` unique identifier of the group
+     - `properties` with a dict with any key: value pairs
+
+     For example:
+     ```python
+     posthog.group_identify('company', 5, {
+         'employees': 11,
+     })
+     ```
+    """
+    _proxy(
+        "group_identify",
+        group_type=group_type,
+        group_key=group_key,
+        properties=properties,
+        context=context,
+        timestamp=timestamp,
+        uuid=uuid,
+    )
 
 
 def alias(
@@ -164,7 +202,7 @@ def alias(
     distinct_id,  # type: str,
     context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
-    message_id=None,  # type: Optional[str]
+    uuid=None,  # type: Optional[str]
 ):
     # type: (...) -> None
     """
@@ -189,7 +227,7 @@ def alias(
         distinct_id=distinct_id,
         context=context,
         timestamp=timestamp,
-        message_id=message_id,
+        uuid=uuid,
     )
 
 
@@ -197,6 +235,9 @@ def feature_enabled(
     key,  # type: str,
     distinct_id,  # type: str,
     default=False,  # type: bool
+    groups={},  # type: dict
+    person_properties={},  # type: dict
+    group_properties={},  # type: dict
 ):
     # type: (...) -> bool
     """
@@ -206,11 +247,86 @@ def feature_enabled(
     ```python
     if posthog.feature_enabled('beta feature', 'distinct id'):
         # do something
+    if posthog.feature_enabled('groups feature', 'distinct id', groups={"organization": "5"}):
+        # do something
     ```
 
     You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.
     """
-    return _proxy("feature_enabled", key=key, distinct_id=distinct_id, default=default)
+    return _proxy(
+        "feature_enabled",
+        key=key,
+        distinct_id=distinct_id,
+        default=default,
+        groups=groups,
+        person_properties=person_properties,
+        group_properties=group_properties,
+    )
+
+
+def get_feature_flag(
+    key,  # type: str,
+    distinct_id,  # type: str,
+    default=False,  # type: bool
+    groups={},  # type: dict
+    person_properties={},  # type: dict
+    group_properties={},  # type: dict
+):
+    """
+    Get feature flag variant for users. Used with experiments.
+    Example:
+    ```python
+    if posthog.get_feature_flag('beta-feature', 'distinct_id') == 'test-variant':
+        # do test variant code
+    if posthog.get_feature_flag('beta-feature', 'distinct_id') == 'control':
+        # do control code
+    ```
+
+    `groups` are a mapping from group type to group key. So, if you have a group type of "organization" and a group key of "5",
+    you would pass groups={"organization": "5"}.
+
+    `group_properties` take the format: { group_type_name: { group_properties } }
+
+    So, for example, if you have the group type "organization" and the group key "5", with the properties name, and employee count,
+    you'll send these as:
+
+    ```python
+        group_properties={"organization": {"name": "PostHog", "employees": 11}}
+    ```
+    """
+    return _proxy(
+        "get_feature_flag",
+        key=key,
+        distinct_id=distinct_id,
+        default=default,
+        groups=groups,
+        person_properties=person_properties,
+        group_properties=group_properties,
+    )
+
+
+def get_all_flags(
+    distinct_id,  # type: str,
+    groups={},  # type: dict
+    person_properties={},  # type: dict
+    group_properties={},  # type: dict
+):
+    """
+    Get all flags for a given user.
+    Example:
+    ```python
+    flags = posthog.get_all_flags('distinct_id')
+    ```
+
+    flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.
+    """
+    return _proxy(
+        "get_all_flags",
+        distinct_id=distinct_id,
+        groups=groups,
+        person_properties=person_properties,
+        group_properties=group_properties,
+    )
 
 
 def page(*args, **kwargs):

posthog/client.py

@@ -1,17 +1,19 @@
 import atexit
-import hashlib
 import logging
 import numbers
+from collections import defaultdict
 from datetime import datetime, timedelta
+from tokenize import group
 from uuid import UUID, uuid4
 
 from dateutil.tz import tzutc
 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.utils import clean, guess_timezone
+from posthog.utils import SizeLimitedDict, clean, guess_timezone
 from posthog.version import VERSION
 
 try:
@@ -21,7 +23,7 @@ except ImportError:
 
 
 ID_TYPES = (numbers.Number, string_types, UUID)
-__LONG_SCALE__ = float(0xFFFFFFFFFFFFFFF)
+MAX_DICT_SIZE = 50_000
 
 
 class Client(object):
@@ -64,14 +66,20 @@ class Client(object):
         self.gzip = gzip
         self.timeout = timeout
         self.feature_flags = None
+        self.group_type_mapping = None
         self.poll_interval = poll_interval
         self.poller = None
+        self.distinct_ids_feature_flags_reported = SizeLimitedDict(MAX_DICT_SIZE, set)
 
         # personal_api_key: This should be a generated Personal API Key, private
         self.personal_api_key = personal_api_key
 
         if debug:
-            self.log.setLevel(logging.DEBUG)
+            # Ensures that debug level messages are logged when debug mode is on.
+            # Otherwise, defaults to WARNING level. See https://docs.python.org/3/howto/logging.html#what-happens-if-no-configuration-is-provided
+            logging.basicConfig(level=logging.DEBUG)
+        else:
+            logging.basicConfig(level=logging.WARNING)
 
         if sync_mode:
             self.consumers = None
@@ -103,7 +111,7 @@ class Client(object):
                 if send:
                     consumer.start()
 
-    def identify(self, distinct_id=None, properties=None, context=None, timestamp=None, message_id=None):
+    def identify(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None):
         properties = properties or {}
         context = context or {}
         require("distinct_id", distinct_id, ID_TYPES)
@@ -115,12 +123,39 @@ class Client(object):
             "distinct_id": distinct_id,
             "$set": properties,
             "event": "$identify",
-            "messageId": message_id,
+            "uuid": uuid,
         }
 
         return self._enqueue(msg)
 
-    def capture(self, distinct_id=None, event=None, properties=None, context=None, timestamp=None, message_id=None):
+    def get_feature_variants(self, distinct_id, groups=None, person_properties=None, group_properties=None):
+        require("distinct_id", distinct_id, ID_TYPES)
+
+        if groups:
+            require("groups", groups, dict)
+        else:
+            groups = {}
+
+        request_data = {
+            "distinct_id": distinct_id,
+            "groups": groups,
+            "person_properties": person_properties,
+            "group_properties": group_properties,
+        }
+        resp_data = decide(self.api_key, self.host, timeout=10, **request_data)
+        return resp_data["featureFlags"]
+
+    def capture(
+        self,
+        distinct_id=None,
+        event=None,
+        properties=None,
+        context=None,
+        timestamp=None,
+        uuid=None,
+        groups=None,
+        send_feature_flags=False,
+    ):
         properties = properties or {}
         context = context or {}
         require("distinct_id", distinct_id, ID_TYPES)
@@ -133,12 +168,26 @@ class Client(object):
             "context": context,
             "distinct_id": distinct_id,
             "event": event,
-            "messageId": message_id,
+            "uuid": uuid,
         }
 
+        if groups:
+            require("groups", groups, dict)
+            msg["properties"]["$groups"] = groups
+
+        if send_feature_flags:
+            try:
+                feature_variants = self.get_feature_variants(distinct_id, groups)
+            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())
+
         return self._enqueue(msg)
 
-    def set(self, distinct_id=None, properties=None, context=None, timestamp=None, message_id=None):
+    def set(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None):
         properties = properties or {}
         context = context or {}
         require("distinct_id", distinct_id, ID_TYPES)
@@ -150,12 +199,12 @@ class Client(object):
             "distinct_id": distinct_id,
             "$set": properties,
             "event": "$set",
-            "messageId": message_id,
+            "uuid": uuid,
         }
 
         return self._enqueue(msg)
 
-    def set_once(self, distinct_id=None, properties=None, context=None, timestamp=None, message_id=None):
+    def set_once(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None):
         properties = properties or {}
         context = context or {}
         require("distinct_id", distinct_id, ID_TYPES)
@@ -167,12 +216,34 @@ class Client(object):
             "distinct_id": distinct_id,
             "$set_once": properties,
             "event": "$set_once",
-            "messageId": message_id,
+            "uuid": uuid,
         }
 
         return self._enqueue(msg)
 
-    def alias(self, previous_id=None, distinct_id=None, context=None, timestamp=None, message_id=None):
+    def group_identify(self, group_type=None, group_key=None, properties=None, context=None, timestamp=None, uuid=None):
+        properties = properties or {}
+        context = context or {}
+        require("group_type", group_type, ID_TYPES)
+        require("group_key", group_key, ID_TYPES)
+        require("properties", properties, dict)
+
+        msg = {
+            "event": "$groupidentify",
+            "properties": {
+                "$group_type": group_type,
+                "$group_key": group_key,
+                "$group_set": properties,
+            },
+            "distinct_id": "${}_{}".format(group_type, group_key),
+            "timestamp": timestamp,
+            "context": context,
+            "uuid": uuid,
+        }
+
+        return self._enqueue(msg)
+
+    def alias(self, previous_id=None, distinct_id=None, context=None, timestamp=None, uuid=None):
         context = context or {}
 
         require("previous_id", previous_id, ID_TYPES)
@@ -191,7 +262,7 @@ class Client(object):
 
         return self._enqueue(msg)
 
-    def page(self, distinct_id=None, url=None, properties=None, context=None, timestamp=None, message_id=None):
+    def page(self, distinct_id=None, url=None, properties=None, context=None, timestamp=None, uuid=None):
         properties = properties or {}
         context = context or {}
 
@@ -207,7 +278,7 @@ class Client(object):
             "timestamp": timestamp,
             "context": context,
             "distinct_id": distinct_id,
-            "messageId": message_id,
+            "uuid": uuid,
         }
 
         return self._enqueue(msg)
@@ -217,9 +288,6 @@ class Client(object):
         timestamp = msg["timestamp"]
         if timestamp is None:
             timestamp = datetime.utcnow().replace(tzinfo=tzutc())
-        message_id = msg.get("messageId")
-        if message_id is None:
-            message_id = uuid4()
 
         require("timestamp", timestamp, datetime)
         require("context", msg["context"], dict)
@@ -227,7 +295,13 @@ class Client(object):
         # add common
         timestamp = guess_timezone(timestamp)
         msg["timestamp"] = timestamp.isoformat()
-        msg["messageId"] = stringify_id(message_id)
+
+        # only send if "uuid" is truthy
+        if "uuid" in msg:
+            uuid = msg.pop("uuid")
+            if uuid:
+                msg["uuid"] = stringify_id(uuid)
+
         if not msg.get("properties"):
             msg["properties"] = {}
         msg["properties"]["$lib"] = "posthog-python"
@@ -286,7 +360,12 @@ class Client(object):
 
     def _load_feature_flags(self):
         try:
-            self.feature_flags = get(self.personal_api_key, "/api/feature_flag/", self.host)["results"]
+            response = get(
+                self.personal_api_key, f"/api/feature_flag/local_evaluation/?token={self.api_key}", self.host
+            )
+            self.feature_flags = response["flags"] or []
+            self.group_type_mapping = response["group_type_mapping"] or {}
+
         except APIError as e:
             if e.status == 401:
                 raise APIError(
@@ -317,53 +396,140 @@ class Client(object):
             self.poller = Poller(interval=timedelta(seconds=self.poll_interval), execute=self._load_feature_flags)
             self.poller.start()
 
-    def feature_enabled(self, key, distinct_id, default=False):
+    def _compute_flag_locally(self, feature_flag, distinct_id, *, groups={}, person_properties={}, group_properties={}):
+
+        if feature_flag.get("ensure_experience_continuity", False):
+            raise InconclusiveMatchError("Flag has experience continuity enabled")
+
+        if not feature_flag.get("active"):
+            return False
+
+        flag_filters = feature_flag.get("filters") or {}
+        aggregation_group_type_index = flag_filters.get("aggregation_group_type_index")
+        if aggregation_group_type_index is not None:
+            group_name = self.group_type_mapping.get(str(aggregation_group_type_index))
+
+            if not group_name:
+                self.log.warning(
+                    f"[FEATURE FLAGS] Unknown group type index {aggregation_group_type_index} for feature flag {feature_flag['key']}"
+                )
+                # failover to `/decide/`
+                raise InconclusiveMatchError("Flag has unknown group type index")
+
+            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"
+                )
+                return False
+
+            focused_group_properties = group_properties[group_name]
+            return match_feature_flag_properties(feature_flag, groups[group_name], focused_group_properties)
+        else:
+            return match_feature_flag_properties(feature_flag, distinct_id, person_properties)
+
+    def feature_enabled(self, key, distinct_id, default=False, *, groups={}, person_properties={}, group_properties={}):
+        return bool(
+            self.get_feature_flag(
+                key,
+                distinct_id,
+                default,
+                groups=groups,
+                person_properties=person_properties,
+                group_properties=group_properties,
+            )
+        )
+
+    def get_feature_flag(
+        self, key, distinct_id, default=False, *, groups={}, person_properties={}, group_properties={}
+    ):
         require("key", key, string_types)
         require("distinct_id", distinct_id, ID_TYPES)
+        require("groups", groups, dict)
 
-        if not self.personal_api_key:
-            self.log.warning("[FEATURE FLAGS] You have to specify a personal_api_key to use feature flags.")
-        if not self.feature_flags:
+        if self.feature_flags == None and self.personal_api_key:
             self.load_feature_flags()
+        response = None
 
         # If loading in previous line failed
-        if not self.feature_flags:
-            response = default
-        else:
+        if self.feature_flags:
+            for flag in self.feature_flags:
+                if flag["key"] == key:
+                    try:
+                        response = self._compute_flag_locally(
+                            flag,
+                            distinct_id,
+                            groups=groups,
+                            person_properties=person_properties,
+                            group_properties=group_properties,
+                        )
+                        self.log.debug(f"Successfully computed flag locally: {key} -> {response}")
+                    except InconclusiveMatchError as e:
+                        self.log.debug(f"Failed to compute flag {key} locally: {e}")
+                        continue
+                    except Exception as e:
+                        self.log.exception(f"[FEATURE FLAGS] Error while computing variant locally: {e}")
+                        continue
+
+        if response is None:
             try:
-                feature_flag = [flag for flag in self.feature_flags if flag["key"] == key][0]
-            except IndexError:
-                return default
+                feature_flags = self.get_feature_variants(
+                    distinct_id, groups=groups, person_properties=person_properties, group_properties=group_properties
+                )
+                response = feature_flags.get(key)
+                self.log.debug(f"Successfully computed flag remotely: #{key} -> #{response}")
+            except Exception as e:
+                self.log.exception(f"[FEATURE FLAGS] Unable to get flag remotely: {e}")
+                response = default
 
-            if feature_flag.get("is_simple_flag"):
-                response = _hash(key, distinct_id) <= ((feature_flag.get("rollout_percentage", 100) or 100) / 100)
-            else:
-                try:
-                    request_data = {
-                        "distinct_id": distinct_id,
-                        "personal_api_key": self.personal_api_key,
-                    }
-                    resp_data = decide(self.api_key, self.host, timeout=10, **request_data)
-                    response = key in resp_data["featureFlags"]
-                except Exception as e:
-                    response = default
-                    self.log.warning(
-                        "[FEATURE FLAGS] Unable to get data for flag %s, because of the following error:" % key
-                    )
-                    self.log.warning(e)
-
-        self.capture(distinct_id, "$feature_flag_called", {"$feature_flag": key, "$feature_flag_response": response})
+        if key not in self.distinct_ids_feature_flags_reported[distinct_id]:
+            self.capture(
+                distinct_id, "$feature_flag_called", {"$feature_flag": key, "$feature_flag_response": response}
+            )
+            self.distinct_ids_feature_flags_reported[distinct_id].add(key)
         return response
 
+    def get_all_flags(self, distinct_id, *, groups={}, person_properties={}, group_properties={}):
+        require("distinct_id", distinct_id, ID_TYPES)
+        require("groups", groups, dict)
 
-# This function takes a distinct_id and a feature flag key and returns a float between 0 and 1.
-# Given the same distinct_id and key, it'll always return the same float. These floats are
-# uniformly distributed between 0 and 1, so if we want to show this feature to 20% of traffic
-# we can do _hash(key, distinct_id) < 0.2
-def _hash(key, distinct_id):
-    hash_key = "%s.%s" % (key, distinct_id)
-    hash_val = int(hashlib.sha1(hash_key.encode("utf-8")).hexdigest()[:15], 16)
-    return hash_val / __LONG_SCALE__
+        if self.feature_flags == None and self.personal_api_key:
+            self.load_feature_flags()
+
+        response = {}
+        fallback_to_decide = False
+
+        # If loading in previous line failed
+        if self.feature_flags:
+            for flag in self.feature_flags:
+                try:
+                    response[flag["key"]] = self._compute_flag_locally(
+                        flag,
+                        distinct_id,
+                        groups=groups,
+                        person_properties=person_properties,
+                        group_properties=group_properties,
+                    )
+                except InconclusiveMatchError as e:
+                    # No need to log this, since it's just telling us to fall back to `/decide`
+                    fallback_to_decide = True
+                except Exception as e:
+                    self.log.exception(f"[FEATURE FLAGS] Error while computing variant: {e}")
+                    fallback_to_decide = True
+        else:
+            fallback_to_decide = True
+
+        if fallback_to_decide:
+            try:
+                feature_flags = self.get_feature_variants(
+                    distinct_id, groups=groups, person_properties=person_properties, group_properties=group_properties
+                )
+                response = {**response, **feature_flags}
+            except Exception as e:
+                self.log.exception(f"[FEATURE FLAGS] Unable to get feature variants: {e}")
+
+        return response
 
 
 def require(name, field, data_type):

posthog/feature_flags.py

@@ -0,0 +1,129 @@
+import hashlib
+import re
+
+from posthog.utils import is_valid_regex
+
+__LONG_SCALE__ = float(0xFFFFFFFFFFFFFFF)
+
+
+class InconclusiveMatchError(Exception):
+    pass
+
+
+# This function takes a distinct_id and a feature flag key and returns a float between 0 and 1.
+# Given the same distinct_id and key, it'll always return the same float. These floats are
+# uniformly distributed between 0 and 1, so if we want to show this feature to 20% of traffic
+# we can do _hash(key, distinct_id) < 0.2
+def _hash(key, distinct_id, salt=""):
+    hash_key = f"{key}.{distinct_id}{salt}"
+    hash_val = int(hashlib.sha1(hash_key.encode("utf-8")).hexdigest()[:15], 16)
+    return hash_val / __LONG_SCALE__
+
+
+def get_matching_variant(flag, distinct_id):
+    hash_value = _hash(flag["key"], distinct_id, salt="variant")
+    for variant in variant_lookup_table(flag):
+        if hash_value >= variant["value_min"] and hash_value < variant["value_max"]:
+            return variant["key"]
+    return None
+
+
+def variant_lookup_table(feature_flag):
+    lookup_table = []
+    value_min = 0
+    multivariates = ((feature_flag.get("filters") or {}).get("multivariate") or {}).get("variants") or []
+    for variant in multivariates:
+        value_max = value_min + variant["rollout_percentage"] / 100
+        lookup_table.append({"value_min": value_min, "value_max": value_max, "key": variant["key"]})
+        value_min = value_max
+    return lookup_table
+
+
+def match_feature_flag_properties(flag, distinct_id, properties):
+    flag_conditions = (flag.get("filters") or {}).get("groups") or []
+    is_inconclusive = False
+
+    for condition in flag_conditions:
+        try:
+            # if any one condition resolves to True, we can shortcircuit and return
+            # the matching variant
+            if is_condition_match(flag, distinct_id, condition, properties):
+                return get_matching_variant(flag, distinct_id) or True
+        except InconclusiveMatchError:
+            is_inconclusive = True
+
+    if is_inconclusive:
+        raise InconclusiveMatchError("Can't determine if feature flag is enabled or not with given properties")
+
+    # We can only return False when either all conditions are False, or
+    # no condition was inconclusive.
+    return False
+
+
+def is_condition_match(feature_flag, distinct_id, condition, properties):
+    rollout_percentage = condition.get("rollout_percentage")
+    if len(condition.get("properties") or []) > 0:
+        if not all(match_property(prop, properties) for prop in condition.get("properties")):
+            return False
+        elif rollout_percentage is None:
+            return True
+
+    if rollout_percentage is not None and _hash(feature_flag["key"], distinct_id) > (rollout_percentage / 100):
+        return False
+
+    return True
+
+
+def match_property(property, property_values) -> bool:
+    # only looks for matches where key exists in override_property_values
+    # doesn't support operator is_not_set
+    key = property.get("key")
+    operator = property.get("operator") or "exact"
+    value = property.get("value")
+
+    if key not in property_values:
+        raise InconclusiveMatchError("can't match properties without a given property value")
+
+    if operator == "is_not_set":
+        raise InconclusiveMatchError("can't match properties with operator is_not_set")
+
+    override_value = property_values[key]
+
+    if operator == "exact":
+        if isinstance(value, list):
+            return override_value in value
+        return value == override_value
+
+    if operator == "is_not":
+        if isinstance(value, list):
+            return override_value not in value
+        return value != override_value
+
+    if operator == "is_set":
+        return key in property_values
+
+    if operator == "icontains":
+        return str(value).lower() in str(override_value).lower()
+
+    if operator == "not_icontains":
+        return str(value).lower() not in str(override_value).lower()
+
+    if operator == "regex":
+        return is_valid_regex(str(value)) and re.compile(str(value)).search(str(override_value)) is not None
+
+    if operator == "not_regex":
+        return is_valid_regex(str(value)) and re.compile(str(value)).search(str(override_value)) is None
+
+    if operator == "gt":
+        return type(override_value) == type(value) and override_value > value
+
+    if operator == "gte":
+        return type(override_value) == type(value) and override_value >= value
+
+    if operator == "lt":
+        return type(override_value) == type(value) and override_value < value
+
+    if operator == "lte":
+        return type(override_value) == type(value) and override_value <= value
+
+    return False

posthog/request.py

@@ -68,7 +68,7 @@ def _process_response(
 
 def decide(api_key: str, host: Optional[str] = None, gzip: bool = False, timeout: int = 15, **kwargs) -> Any:
     """Post the `kwargs to the decide API endpoint"""
-    res = post(api_key, host, "/decide/", gzip, timeout, **kwargs)
+    res = post(api_key, host, "/decide/?v=2", gzip, timeout, **kwargs)
     return _process_response(res, success_message="Feature flags decided successfully")
 
 

posthog/sentry/posthog_integration.py

@@ -1,7 +1,9 @@
 from sentry_sdk._types import MYPY
+from sentry_sdk.client import Client
 from sentry_sdk.hub import Hub
 from sentry_sdk.integrations import Integration
 from sentry_sdk.scope import add_global_event_processor
+from sentry_sdk.utils import Dsn
 
 import posthog
 from posthog.request import DEFAULT_HOST
@@ -17,7 +19,7 @@ class PostHogIntegration(Integration):
     identifier = "posthog-python"
     organization = None  # The Sentry organization, used to send a direct link from PostHog to Sentry
     project_id = None  # The Sentry project id, used to send a direct link from PostHog to Sentry
-    prefix = "https://sentry.io/organizations/"  # Url of a self-hosted sentry instance (default: https://sentry.io/organizations/)
+    prefix = "https://sentry.io/organizations/"  # URL of a hosted sentry instance (default: https://sentry.io/organizations/)
 
     @staticmethod
     def setup_once():
@@ -37,10 +39,14 @@ class PostHogIntegration(Integration):
                         "$sentry_exception": event["exception"],
                     }
 
-                    if PostHogIntegration.organization and PostHogIntegration.project_id:
-                        properties[
-                            "$sentry_url"
-                        ] = f"{PostHogIntegration.prefix}{PostHogIntegration.organization}/issues/?project={PostHogIntegration.project_id}&query={event['event_id']}"
+                    if PostHogIntegration.organization:
+                        project_id = PostHogIntegration.project_id or (
+                            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']}"
 
                     posthog.capture(posthog_distinct_id, "$exception", properties)
 

posthog/test/test_client.py

@@ -1,19 +1,31 @@
 import time
 import unittest
 from datetime import date, datetime
+from unittest.mock import MagicMock
 from uuid import uuid4
 
 import mock
 import six
-from freezegun import freeze_time
 
 from posthog.client import Client
-from posthog.request import APIError
-from posthog.test.test_utils import TEST_API_KEY
+from posthog.test.test_utils import FAKE_TEST_API_KEY
 from posthog.version import VERSION
 
 
 class TestClient(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # This ensures no real HTTP POST requests are made
+        cls.client_post_patcher = mock.patch("posthog.client.batch_post")
+        cls.consumer_post_patcher = mock.patch("posthog.consumer.batch_post")
+        cls.client_post_patcher.start()
+        cls.consumer_post_patcher.start()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.client_post_patcher.stop()
+        cls.consumer_post_patcher.stop()
+
     def set_fail(self, e, batch):
         """Mark the failure handler"""
         print("FAIL", e, batch)
@@ -21,7 +33,7 @@ class TestClient(unittest.TestCase):
 
     def setUp(self):
         self.failed = False
-        self.client = Client(TEST_API_KEY, on_error=self.set_fail)
+        self.client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail)
 
     def test_requires_api_key(self):
         self.assertRaises(AssertionError, Client)
@@ -38,14 +50,29 @@ class TestClient(unittest.TestCase):
 
         self.assertEqual(msg["event"], "python test event")
         self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertTrue(isinstance(msg["messageId"], 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)
+
+    def test_basic_capture_with_uuid(self):
+        client = self.client
+        uuid = str(uuid4())
+        success, msg = client.capture("distinct_id", "python test event", uuid=uuid)
+        client.flush()
+        self.assertTrue(success)
+        self.assertFalse(self.failed)
+
+        self.assertEqual(msg["event"], "python test event")
+        self.assertTrue(isinstance(msg["timestamp"], str))
+        self.assertEqual(msg["uuid"], uuid)
         self.assertEqual(msg["distinct_id"], "distinct_id")
         self.assertEqual(msg["properties"]["$lib"], "posthog-python")
         self.assertEqual(msg["properties"]["$lib_version"], VERSION)
 
     def test_basic_capture_with_project_api_key(self):
 
-        client = Client(project_api_key=TEST_API_KEY, on_error=self.set_fail)
+        client = Client(project_api_key=FAKE_TEST_API_KEY, on_error=self.set_fail)
 
         success, msg = client.capture("distinct_id", "python test event")
         client.flush()
@@ -54,11 +81,53 @@ class TestClient(unittest.TestCase):
 
         self.assertEqual(msg["event"], "python test event")
         self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertTrue(isinstance(msg["messageId"], 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)
 
+    @mock.patch("posthog.client.decide")
+    def test_basic_capture_with_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)
+        success, msg = client.capture("distinct_id", "python test event", send_feature_flags=True)
+        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"], "random-variant")
+        self.assertEqual(msg["properties"]["$active_feature_flags"], ["beta-feature"])
+
+        self.assertEqual(patch_decide.call_count, 1)
+
+    @mock.patch("posthog.client.decide")
+    def test_basic_capture_with_feature_flags_switched_off_doesnt_send_them(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)
+        success, msg = client.capture("distinct_id", "python test event", send_feature_flags=False)
+        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.assertTrue("$feature/beta-feature" not in msg["properties"])
+        self.assertTrue("$active_feature_flags" not in msg["properties"])
+
+        self.assertEqual(patch_decide.call_count, 0)
+
     def test_stringifies_distinct_id(self):
         # A large number that loses precision in node:
         # node -e "console.log(157963456373623802 + 1)" > 157963456373623800
@@ -78,7 +147,7 @@ class TestClient(unittest.TestCase):
             {"property": "value"},
             {"ip": "192.168.0.1"},
             datetime(2014, 9, 3),
-            "messageId",
+            "new-uuid",
         )
 
         self.assertTrue(success)
@@ -89,8 +158,19 @@ class TestClient(unittest.TestCase):
         self.assertEqual(msg["event"], "python test event")
         self.assertEqual(msg["properties"]["$lib"], "posthog-python")
         self.assertEqual(msg["properties"]["$lib_version"], VERSION)
-        self.assertEqual(msg["messageId"], "messageId")
+        self.assertEqual(msg["uuid"], "new-uuid")
         self.assertEqual(msg["distinct_id"], "distinct_id")
+        self.assertTrue("$groups" not in msg["properties"])
+
+    def test_groups_capture(self):
+        success, msg = self.client.capture(
+            "distinct_id",
+            "test_event",
+            groups={"company": "id:5", "instance": "app.posthog.com"},
+        )
+
+        self.assertTrue(success)
+        self.assertEqual(msg["properties"]["$groups"], {"company": "id:5", "instance": "app.posthog.com"})
 
     def test_basic_identify(self):
         client = self.client
@@ -101,13 +181,13 @@ class TestClient(unittest.TestCase):
 
         self.assertEqual(msg["$set"]["trait"], "value")
         self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertTrue(isinstance(msg["messageId"], str))
+        self.assertIsNone(msg.get("uuid"))
         self.assertEqual(msg["distinct_id"], "distinct_id")
 
     def test_advanced_identify(self):
         client = self.client
         success, msg = client.identify(
-            "distinct_id", {"trait": "value"}, {"ip": "192.168.0.1"}, datetime(2014, 9, 3), "messageId"
+            "distinct_id", {"trait": "value"}, {"ip": "192.168.0.1"}, datetime(2014, 9, 3), "new-uuid"
         )
 
         self.assertTrue(success)
@@ -118,7 +198,7 @@ class TestClient(unittest.TestCase):
         self.assertEqual(msg["properties"]["$lib"], "posthog-python")
         self.assertEqual(msg["properties"]["$lib_version"], VERSION)
         self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertEqual(msg["messageId"], "messageId")
+        self.assertEqual(msg["uuid"], "new-uuid")
         self.assertEqual(msg["distinct_id"], "distinct_id")
 
     def test_basic_set(self):
@@ -130,13 +210,13 @@ class TestClient(unittest.TestCase):
 
         self.assertEqual(msg["$set"]["trait"], "value")
         self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertTrue(isinstance(msg["messageId"], str))
+        self.assertIsNone(msg.get("uuid"))
         self.assertEqual(msg["distinct_id"], "distinct_id")
 
     def test_advanced_set(self):
         client = self.client
         success, msg = client.set(
-            "distinct_id", {"trait": "value"}, {"ip": "192.168.0.1"}, datetime(2014, 9, 3), "messageId"
+            "distinct_id", {"trait": "value"}, {"ip": "192.168.0.1"}, datetime(2014, 9, 3), "new-uuid"
         )
 
         self.assertTrue(success)
@@ -147,7 +227,7 @@ class TestClient(unittest.TestCase):
         self.assertEqual(msg["properties"]["$lib"], "posthog-python")
         self.assertEqual(msg["properties"]["$lib_version"], VERSION)
         self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertEqual(msg["messageId"], "messageId")
+        self.assertEqual(msg["uuid"], "new-uuid")
         self.assertEqual(msg["distinct_id"], "distinct_id")
 
     def test_basic_set_once(self):
@@ -159,13 +239,13 @@ class TestClient(unittest.TestCase):
 
         self.assertEqual(msg["$set_once"]["trait"], "value")
         self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertTrue(isinstance(msg["messageId"], str))
+        self.assertIsNone(msg.get("uuid"))
         self.assertEqual(msg["distinct_id"], "distinct_id")
 
     def test_advanced_set_once(self):
         client = self.client
         success, msg = client.set_once(
-            "distinct_id", {"trait": "value"}, {"ip": "192.168.0.1"}, datetime(2014, 9, 3), "messageId"
+            "distinct_id", {"trait": "value"}, {"ip": "192.168.0.1"}, datetime(2014, 9, 3), "new-uuid"
         )
 
         self.assertTrue(success)
@@ -176,9 +256,49 @@ class TestClient(unittest.TestCase):
         self.assertEqual(msg["properties"]["$lib"], "posthog-python")
         self.assertEqual(msg["properties"]["$lib_version"], VERSION)
         self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertEqual(msg["messageId"], "messageId")
+        self.assertEqual(msg["uuid"], "new-uuid")
         self.assertEqual(msg["distinct_id"], "distinct_id")
 
+    def test_basic_group_identify(self):
+        success, msg = self.client.group_identify("organization", "id:5")
+
+        self.assertTrue(success)
+        self.assertEqual(msg["event"], "$groupidentify")
+        self.assertEqual(msg["distinct_id"], "$organization_id:5")
+        self.assertEqual(
+            msg["properties"],
+            {
+                "$group_type": "organization",
+                "$group_key": "id:5",
+                "$group_set": {},
+                "$lib": "posthog-python",
+                "$lib_version": VERSION,
+            },
+        )
+        self.assertTrue(isinstance(msg["timestamp"], str))
+        self.assertIsNone(msg.get("uuid"))
+
+    def test_advanced_group_identify(self):
+        success, msg = self.client.group_identify(
+            "organization", "id:5", {"trait": "value"}, {"ip": "192.168.0.1"}, datetime(2014, 9, 3), "new-uuid"
+        )
+
+        self.assertTrue(success)
+        self.assertEqual(msg["event"], "$groupidentify")
+        self.assertEqual(msg["distinct_id"], "$organization_id:5")
+        self.assertEqual(
+            msg["properties"],
+            {
+                "$group_type": "organization",
+                "$group_key": "id:5",
+                "$group_set": {"trait": "value"},
+                "$lib": "posthog-python",
+                "$lib_version": VERSION,
+            },
+        )
+        self.assertEqual(msg["timestamp"], "2014-09-03T00:00:00+00:00")
+        self.assertEqual(msg["context"]["ip"], "192.168.0.1")
+
     def test_basic_alias(self):
         client = self.client
         success, msg = client.alias("previousId", "distinct_id")
@@ -215,7 +335,7 @@ class TestClient(unittest.TestCase):
             {"property": "value"},
             {"ip": "192.168.0.1"},
             datetime(2014, 9, 3),
-            "messageId",
+            "new-uuid",
         )
 
         self.assertTrue(success)
@@ -227,7 +347,7 @@ class TestClient(unittest.TestCase):
         self.assertEqual(msg["properties"]["$lib"], "posthog-python")
         self.assertEqual(msg["properties"]["$lib_version"], VERSION)
         self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertEqual(msg["messageId"], "messageId")
+        self.assertEqual(msg["uuid"], "new-uuid")
         self.assertEqual(msg["distinct_id"], "distinct_id")
 
     def test_flush(self):
@@ -255,7 +375,7 @@ class TestClient(unittest.TestCase):
             self.assertFalse(consumer.is_alive())
 
     def test_synchronous(self):
-        client = Client(TEST_API_KEY, sync_mode=True)
+        client = Client(FAKE_TEST_API_KEY, sync_mode=True)
 
         success, message = client.identify("distinct_id")
         self.assertFalse(client.consumers)
@@ -263,7 +383,7 @@ class TestClient(unittest.TestCase):
         self.assertTrue(success)
 
     def test_overflow(self):
-        client = Client(TEST_API_KEY, max_queue_size=1)
+        client = Client(FAKE_TEST_API_KEY, max_queue_size=1)
         # Ensure consumer thread is no longer uploading
         client.join()
 
@@ -286,17 +406,17 @@ class TestClient(unittest.TestCase):
         Client("bad_key", debug=True)
 
     def test_gzip(self):
-        client = Client(TEST_API_KEY, on_error=self.fail, gzip=True)
+        client = Client(FAKE_TEST_API_KEY, on_error=self.fail, gzip=True)
         for _ in range(10):
             client.identify("distinct_id", {"trait": "value"})
         client.flush()
         self.assertFalse(self.failed)
 
     def test_user_defined_flush_at(self):
-        client = Client(TEST_API_KEY, on_error=self.fail, flush_at=10, flush_interval=3)
+        client = Client(FAKE_TEST_API_KEY, on_error=self.fail, flush_at=10, flush_interval=3)
 
         def mock_post_fn(*args, **kwargs):
-            self.assertEquals(len(kwargs["batch"]), 10)
+            self.assertEqual(len(kwargs["batch"]), 10)
 
         # the post function should be called 2 times, with a batch size of 10
         # each time.
@@ -304,102 +424,17 @@ class TestClient(unittest.TestCase):
             for _ in range(20):
                 client.identify("distinct_id", {"trait": "value"})
             time.sleep(1)
-            self.assertEquals(mock_post.call_count, 2)
+            self.assertEqual(mock_post.call_count, 2)
 
     def test_user_defined_timeout(self):
-        client = Client(TEST_API_KEY, timeout=10)
+        client = Client(FAKE_TEST_API_KEY, timeout=10)
         for consumer in client.consumers:
-            self.assertEquals(consumer.timeout, 10)
+            self.assertEqual(consumer.timeout, 10)
 
     def test_default_timeout_15(self):
-        client = Client(TEST_API_KEY)
+        client = Client(FAKE_TEST_API_KEY)
         for consumer in client.consumers:
-            self.assertEquals(consumer.timeout, 15)
-
-    @mock.patch("posthog.client.Poller")
-    @mock.patch("posthog.client.get")
-    def test_load_feature_flags(self, patch_get, patch_poll):
-        patch_get.return_value = {"results": [{"id": 1, "name": "Beta Feature", "key": "beta-feature"}]}
-        client = Client(TEST_API_KEY, personal_api_key="test")
-        with freeze_time("2020-01-01T12:01:00.0000Z"):
-            client.load_feature_flags()
-        self.assertEqual(client.feature_flags[0]["key"], "beta-feature")
-        self.assertEqual(client._last_feature_flag_poll.isoformat(), "2020-01-01T12:01:00+00:00")
-        self.assertEqual(patch_poll.call_count, 1)
-
-    def test_load_feature_flags_wrong_key(self):
-        client = Client(TEST_API_KEY, personal_api_key=TEST_API_KEY)
-        with freeze_time("2020-01-01T12:01:00.0000Z"):
-            self.assertRaises(APIError, client.load_feature_flags)
-
-    @mock.patch("posthog.client.get")
-    def test_feature_enabled_simple(self, patch_get):
-        client = Client(TEST_API_KEY)
-        client.feature_flags = [
-            {"id": 1, "name": "Beta Feature", "key": "beta-feature", "is_simple_flag": True, "rollout_percentage": 100}
-        ]
-        self.assertTrue(client.feature_enabled("beta-feature", "distinct_id"))
-
-    @mock.patch("posthog.client.get")
-    def test_feature_enabled_simple_with_project_api_key(self, patch_get):
-        client = Client(project_api_key=TEST_API_KEY, on_error=self.set_fail)
-        client.feature_flags = [
-            {"id": 1, "name": "Beta Feature", "key": "beta-feature", "is_simple_flag": True, "rollout_percentage": 100}
-        ]
-        self.assertTrue(client.feature_enabled("beta-feature", "distinct_id"))
-
-    @mock.patch("posthog.client.decide")
-    def test_feature_enabled_request(self, patch_decide):
-        patch_decide.return_value = {"featureFlags": ["beta-feature"]}
-        client = Client(TEST_API_KEY)
-        client.feature_flags = [
-            {"id": 1, "name": "Beta Feature", "key": "beta-feature", "is_simple_flag": False, "rollout_percentage": 100}
-        ]
-        self.assertTrue(client.feature_enabled("beta-feature", "distinct_id"))
-
-    @mock.patch("posthog.client.get")
-    def test_feature_enabled_simple_without_rollout_percentage(self, patch_get):
-        client = Client(TEST_API_KEY)
-        client.feature_flags = [{"id": 1, "name": "Beta Feature", "key": "beta-feature", "is_simple_flag": True}]
-        self.assertTrue(client.feature_enabled("beta-feature", "distinct_id"))
-
-    @mock.patch("posthog.client.get")
-    def test_feature_enabled_simple_with_none_rollout_percentage(self, patch_get):
-        client = Client(TEST_API_KEY)
-        client.feature_flags = [
-            {"id": 1, "name": "Beta Feature", "key": "beta-feature", "is_simple_flag": True, "rollout_percantage": None}
-        ]
-        self.assertTrue(client.feature_enabled("beta-feature", "distinct_id"))
-
-    @mock.patch("posthog.client.Poller")
-    @mock.patch("posthog.client.get")
-    def test_feature_enabled_doesnt_exist(self, patch_get, patch_poll):
-        client = Client(TEST_API_KEY, personal_api_key="test")
-        client.feature_flags = []
-
-        self.assertFalse(client.feature_enabled("doesnt-exist", "distinct_id"))
-        self.assertTrue(client.feature_enabled("doesnt-exist", "distinct_id", True))
-
-    @mock.patch("posthog.client.Poller")
-    @mock.patch("posthog.client.get")
-    def test_personal_api_key_doesnt_exist(self, patch_get, patch_poll):
-        client = Client(TEST_API_KEY)
-        client.feature_flags = []
-
-        self.assertFalse(client.feature_enabled("doesnt-exist", "distinct_id"))
-        self.assertTrue(client.feature_enabled("doesnt-exist", "distinct_id", True))
-
-    @mock.patch("posthog.client.Poller")
-    @mock.patch("posthog.client.get")
-    def test_load_feature_flags_error(self, patch_get, patch_poll):
-        def raise_effect():
-            raise Exception("http exception")
-
-        patch_get.return_value.raiseError.side_effect = raise_effect
-        client = Client(TEST_API_KEY, personal_api_key="test")
-        client.feature_flags = []
-
-        self.assertFalse(client.feature_enabled("doesnt-exist", "distinct_id"))
+            self.assertEqual(consumer.timeout, 15)
 
     @mock.patch("posthog.client.Poller")
     @mock.patch("posthog.client.get")
@@ -408,7 +443,7 @@ class TestClient(unittest.TestCase):
             raise Exception("http exception")
 
         patch_get.return_value.raiseError.side_effect = raise_effect
-        client = Client(TEST_API_KEY, personal_api_key="test")
+        client = Client(FAKE_TEST_API_KEY, personal_api_key="test")
         client.feature_flags = [{"key": "example", "is_simple_flag": False}]
 
         self.assertFalse(client.feature_enabled("example", "distinct_id"))

posthog/test/test_consumer.py

@@ -161,4 +161,4 @@ class TestConsumer(unittest.TestCase):
             for _ in range(0, n_msgs + 2):
                 q.put(track)
             q.join()
-            self.assertEquals(mock_post.call_count, 2)
+            self.assertEqual(mock_post.call_count, 2)

posthog/test/test_utils.py

@@ -9,6 +9,7 @@ from dateutil.tz import tzutc
 from posthog import utils
 
 TEST_API_KEY = "kOOlRy2QlMY9jHZQv0bKz0FZyazBUoY8Arj0lFVNjs4"
+FAKE_TEST_API_KEY = "random_key"
 
 
 class TestUtils(unittest.TestCase):
@@ -79,3 +80,22 @@ class TestUtils(unittest.TestCase):
     def test_remove_slash(self):
         self.assertEqual("http://posthog.io", utils.remove_trailing_slash("http://posthog.io/"))
         self.assertEqual("http://posthog.io", utils.remove_trailing_slash("http://posthog.io"))
+
+
+class TestSizeLimitedDict(unittest.TestCase):
+    def test_size_limited_dict(self):
+        size = 10
+        values = utils.SizeLimitedDict(size, lambda _: -1)
+
+        for i in range(100):
+            values[i] = i
+
+            self.assertEqual(values[i], i)
+            self.assertEqual(len(values), i % size + 1)
+
+            if i % size == 0:
+                # old numbers should've been removed
+                self.assertIsNone(values.get(i - 1))
+                self.assertIsNone(values.get(i - 3))
+                self.assertIsNone(values.get(i - 5))
+                self.assertIsNone(values.get(i - 9))

posthog/utils.py

@@ -1,5 +1,7 @@
 import logging
 import numbers
+import re
+from collections import defaultdict
 from datetime import date, datetime
 from decimal import Decimal
 from uuid import UUID
@@ -87,3 +89,23 @@ def _coerce_unicode(cmplx):
         log.warning("Error decoding: %s", item)
         return None
     return item
+
+
+def is_valid_regex(value) -> bool:
+    try:
+        re.compile(value)
+        return True
+    except re.error:
+        return False
+
+
+class SizeLimitedDict(defaultdict):
+    def __init__(self, max_size, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.max_size = max_size
+
+    def __setitem__(self, key, value):
+        if len(self) >= self.max_size:
+            self.clear()
+
+        super().__setitem__(key, value)

posthog/version.py

@@ -1 +1,4 @@
-VERSION = "1.4.0"
+VERSION = "2.0.0"
+
+if __name__ == "__main__":
+    print(VERSION, end="")

sentry_django_example/sentry_django_example/settings.py

@@ -44,7 +44,6 @@ posthog.host = "http://127.0.0.1:8000"
 from posthog.sentry.posthog_integration import PostHogIntegration
 
 PostHogIntegration.organization = "posthog"  # TODO: your sentry organization
-PostHogIntegration.project_id = "5624115"  # TODO: your sentry projectID
 # PostHogIntegration.prefix = # TODO: your self hosted Sentry url. (default: https://sentry.io/organizations/)
 
 # Since Sentry doesn't allow Integrations configuration (see https://github.com/getsentry/sentry-python/blob/master/sentry_sdk/integrations/__init__.py#L171-L183)

setup.py

@@ -14,7 +14,7 @@ long_description = """
 PostHog is developer-friendly, self-hosted product analytics. posthog-python is the python package.
 """
 
-install_requires = ["requests>=2.7,<3.0", "six>=1.5", "monotonic>=1.5", "backoff==1.6.0", "python-dateutil>2.1"]
+install_requires = ["requests>=2.7,<3.0", "six>=1.5", "monotonic>=1.5", "backoff>=1.10.0,<2.0.0", "python-dateutil>2.1"]
 
 extras_require = {
     "dev": [
@@ -22,7 +22,7 @@ extras_require = {
         "isort",
         "pre-commit",
     ],
-    "test": ["mock>=2.0.0", "freezegun==0.3.15", "pylint", "flake8", "coverage"],
+    "test": ["mock>=2.0.0", "freezegun==0.3.15", "pylint", "flake8", "coverage", "pytest"],
     "sentry": ["sentry-sdk", "django"],
 }
 
@@ -35,7 +35,7 @@ setup(
     maintainer="PostHog",
     maintainer_email="hey@posthog.com",
     test_suite="posthog.test.all",
-    packages=["posthog", "posthog.test"],
+    packages=["posthog", "posthog.test", "posthog.sentry"],
     license="MIT License",
     install_requires=install_requires,
     extras_require=extras_require,

setup_analytics.py

@@ -27,7 +27,7 @@ setup(
     maintainer="PostHog",
     maintainer_email="hey@posthog.com",
     test_suite="posthoganalytics.test.all",
-    packages=["posthoganalytics", "posthoganalytics.test"],
+    packages=["posthoganalytics", "posthoganalytics.test", "posthoganalytics.sentry"],
     license="MIT License",
     install_requires=install_requires,
     tests_require=tests_require,