feat: Add feature flag checking for rust and python

[markstory]

Continue work started in #91 to add methods for checking feature flags from both rust + python. I'd like to spend some more time expanding python tests to include more of the existing flagpole tests to ensure that flag checking behavior is consistent. I can do that separately as these changes are large already.

[markstory]

This test matches the attributes and rollout bucket assignments in getsentry/sentry#109822

[kenzoengineer]

i assume we use Cell so we don't need to pass around &mut self? (asking for my own learning)

[markstory]

Yes it lets the outer struct be immutable, but the cached_id can be mutable. This also goes by interior mutability

[kenzoengineer]

this enum seems like a lot of code to hold a generic list of objects and perform an operation on them (to_id_string()), could we just reuse serde_json::Value?

the one downside is it'll make it a bit less object oriented:

• (to_id_string()) will live on its own
• we reuse serde_json::Value when it doesn't have anything to do with json

i got an LLM to preview what that would look like: #94

what do you think?

[markstory]

... could we just reuse serde_json::Value?

We could. That would be simpler 👍

[kenzoengineer]

this seems to be <= in sentry src/flagpole/conditions.py https://github.com/getsentry/sentry/blob/master/src/flagpole/conditions.py#L251

[kenzoengineer]

Suggested change

	context.id() % 100 < self.rollout
	context.id() % 100 <= self.rollout

[kenzoengineer]

ah wait, i see you made this change in e5b80b3. I guess flagpole has always been wrong then? < would be mathematically correct as % 100 returns [0, 99] and 0 <= 0 would match the flag..

i guess this is an improvement then!

[markstory]

Yes, the python implementation has an off-by one error. I thought this was a good time to fix that mistake. It will change rollout groups though which could pose a problem during the transition from the current implementation to this one.

[kenzoengineer]

linking this PR to https://linear.app/getsentry/issue/DI-1686/flagpole-support

[cursor]

Cursor Bugbot has reviewed your changes and found 2 potential issues.

^{Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

[markstory]

I was curious about the memory impacts and runtime behavior of this implementation. I had claude convert all of our existing feature flags (290 of them) to sentry-options values format, and generate a schema namespace schema for them. I wrote up a small jank script that looks like

Details

import contextlib
import resource
import sentry_options
import time

@contextlib.contextmanager
def timer(name: str):
    start_mem = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
    start = time.time()
    yield
    end = time.time()
    end_mem = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss

    duration = end - start
    print(f"> {name} : {duration:.8f}")
    mem_diff = end_mem - start_mem
    if mem_diff > 1_000_000:
        print(f"! memory increase: {name} : {mem_diff:.2f}")


def main():
    print("with sentry-options")
    with timer("init()"):
        sentry_options.init()

    ctx = sentry_options.FeatureContext(
        {
            "organization_id": 1,
            "organization_slug": "sentry",
            "user_email": "mark@sentry.io",
        },
        identity_fields=["organization_id"]
    )
    with timer("check single feature once"):
        assert sentry_options.features("flagpole").has("organizations:anomaly-detection-eap", ctx)

    with timer("check single feature 10000 times"):
        for i in range(10000):
            sentry_options.features("flagpole").has("organizations:anomaly-detection-eap", ctx)

if __name__ == "__main__":
    main()

Running this locally yielded:

with sentry-options
> init() : 2.23160505
! memory increase: init() : 30572544.00
> check single feature once : 0.00007677
> check single feature 10000 times : 0.13953114

The init() function will add ~2s to application startup time, but after that feature flag checks are quite efficient compared to the overhead of checking a feature today. I built a similar test for the existing flagpole implementation:

Details

import contextlib
import resource
import time

from sentry.runner import configure

configure()

from sentry import options
from sentry import features
from flagpole import Feature, EvaluationContext


@contextlib.contextmanager
def timer(name: str) -> None:
    start_mem = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
    start = time.time()
    yield
    end = time.time()
    end_mem = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss

    duration = end - start
    print(f"> {name} : {duration:.8f}")
    mem_diff = end_mem - start_mem
    if mem_diff > 100_000:
        print(f"! memory increase: {name} : {mem_diff:.2f}")

def main() -> None:
    print("sentry flagpole timing")

    ctx = EvaluationContext(
        {
            "organization_id": 1,
            "organization_slug": "sentry",
            "user_email": "mark@sentry.io",
        },
        identity_fields=set(["organization_id"])
    )
    with timer("check single feature once"):
        name = "organizations:anomaly-detection-eap"
        config = options.get(f"feature.{name}")
        feature = Feature.from_feature_dictionary(name, config)
        assert feature.match(ctx)

    with timer("check single feature 10000 times"):
        name = "organizations:anomaly-detection-eap"
        for i in range(10000):
            config = options.get(f"feature.{name}")
            feature = Feature.from_feature_dictionary(name, config)
            feature.match(ctx)

    with timer("check every feature 100 times"):
        for key in features.all().keys():
            if key.startswith("feature"):
                name = key.split(".")[1]
                for i in range(100):
                    config = options.get(f"feature.{name}")
                    feature = Feature.from_feature_config_json(name, config)
                    feature.match(ctx)



if __name__ == "__main__":
    main()

and got higher durations for both the single and many checks.

sentry flagpole timing
> check single feature once : 0.00123692
> check single feature 10000 times : 0.07596898