Skip to content

feat(flags): support known-absent property keys in local evaluation - #1280

Open
marandaneto wants to merge 7 commits into
mainfrom
feat/flags-known-absent-property-keys
Open

marandaneto wants to merge 7 commits into
mainfrom
feat/flags-known-absent-property-keys

Conversation

@marandaneto

@marandaneto marandaneto commented Nov 19, 2026 •

Copy link
Copy Markdown
Member

💡 Motivation and Context

Closes the Python part of PostHog/posthog#88947.

Local flag evaluation can't tell a missing property apart from one the caller didn't pass. If a key is left out of person_properties, the condition that reads it is inconclusive and the SDK asks /flags. Callers had no way to say "this person definitely doesn't have plan". So a flag with plan is_not_set could never resolve locally. The local result and the /flags result could also disagree.

The flags service now accepts known-absent keys (PostHog/posthog#138239). This PR adds the same input to the SDK, following the cross-SDK spec in PostHog/sdk-specs#233.

New input

Two optional keyword arguments:

  • person_property_keys_known_absent: a collection of person property keys.
  • group_property_keys_known_absent: a mapping from group type to a collection of group property keys.
flags = posthog.evaluate_flags(
    "user-1",
    person_properties={"email": "a@example.com"},
    person_property_keys_known_absent=["plan"],
    groups={"organization": "org-1"},
    group_property_keys_known_absent={"organization": ["tier"]},
)

They are accepted by evaluate_flags, get_feature_flag, get_feature_flag_result, feature_enabled, get_feature_flag_payload, get_all_flags, get_all_flags_and_payloads, get_feature_variants, get_feature_payloads, get_feature_flags_and_payloads, get_flags_decision, and the module-level wrappers. They also work in capture(send_feature_flags={...}) and in AsyncClient.evaluate_flags. Existing signatures don't change.

Local evaluation

  • A listed key counts as absent, even when the caller also passes a value for it. This also overrides values the SDK adds itself, such as distinct_id and $group_key.
  • For a listed key, is_not_set, is_not, not_icontains, not_starts_with, not_ends_with and not_regex match. Every other supported operator does not match. That includes is_set, exact, gt, all semver_* operators and the date operators. The result is final, with no /flags request.
  • Unsupported operators and invalid filters are still checked first. They stay inconclusive and fall back to /flags even when the key is listed.
  • Operator support is checked before the known-absent table, in flag conditions and in cohort leaves, as required by the latest spec revision (docs(flags): specify known-absent property keys sdk-specs#233). test_cohort_leaf_unsupported_operator_falls_back_before_known_absence covers a cohort leaf plan not_between [1, 2] with and without negation.
  • A key that is left out and not listed stays inconclusive, same as today.
  • Person keys starting with __posthog_person_metadata__ are ignored.
  • Group keys only apply to their own group type. Person keys don't apply to group properties.
  • Cohort property conditions use the absent result before applying the condition's negation. Flag dependencies are evaluated with the same listed keys.
  • A listed $feature_enrollment/<flag key> means the person is not enrolled. Evaluation then continues to holdouts and release conditions instead of returning early or falling back. Python is the only SDK with local enrollment handling.

/flags request body

When the SDK calls /flags and the caller listed keys, the body includes person_property_keys_known_absent: [...] and group_property_keys_known_absent: {"<group type>": [...]}. This happens for local fallback, forced remote calls, and remote-only calls. A field is left out when it wasn't provided or is empty.

Limits

Each list holds at most 1000 keys. Duplicates count. For groups the limit applies per group type. A longer list raises ValueError from the flag getters. Nothing is evaluated and no request is sent. The SDK never truncates the list. Wrong types raise TypeError, for example a plain string or a non-string group type. With capture(send_feature_flags={...}), the error is handled like other capture errors. capture logs it and returns None, and no event is sent. With debug=True it raises.

Compliance adapter

The adapter now declares feature_flags_known_absent_v1. /get_feature_flag passes both new params to the SDK unchanged. It also accepts allow_remote_fallback: true, which calls the default getter on the client with local definitions. That mode returns HTTP 400 when combined with force_remote: true or only_evaluate_locally: true.

Not included

Links

💚 How did you test it?

New tests in posthog/test/test_feature_flags_known_absent.py:

  • Every supported operator on a listed key, resolved locally with no request.
  • A listed key overriding a supplied value, the SDK-added distinct_id, and $group_key.
  • An omitted key that isn't listed still falling back to /flags.
  • The metadata prefix being ignored.
  • Group-type scoping, and person keys not applying to groups.
  • An unsupported filter on a listed key still falling back.
  • Cohort conditions with and without negation, and a flag dependency.
  • Enrollment continuing to release conditions and holdouts, and group enrollment staying unsupported.
  • The /flags body including the fields on fallback and on every remote entry point, including capture(send_feature_flags=...) and async evaluate_flags. The fields are left out when not provided or empty.
  • The 1000-key limit. This covers duplicates, the per-group-type limit, unbounded iterators, the capture path with default and debug settings, and wrong types.
  • Iterator inputs reaching the /flags body.

sdk_compliance_adapter/test_adapter.py covers the new adapter params and allow_remote_fallback.

Commands run locally with uv run --no-sync on macOS:

  • ruff format --check . passed.
  • ruff check . passed.
  • mypy --no-site-packages --config-file mypy.ini . | mypy-baseline filter passed.
  • make public_api_check passed. The snapshot is updated in this PR.
  • python -W error -c "import posthog" passed.
  • pytest sdk_compliance_adapter/test_adapter.py passed.
  • pytest --timeout=30 gave 8397 passed and 3 failed. The 3 failures are fork tests in posthog/test/test_metrics_autocapture.py. They also fail on unchanged main on macOS.

After the spec revision I added the cohort-leaf test. It passed with no production change. I re-ran ruff format --check ., ruff check ., mypy with the baseline filter, make public_api_check and python -W error -c "import posthog", and all passed. pytest --timeout=30 gave 8399 passed and the same 3 fork test failures in posthog/test/test_metrics_autocapture.py.

CI now runs SDK test harness 1.34.0. The feature_flags_known_absent suite ran and passed 12/12 in each compliance job (gzip, deflate and zstd).

📝 Checklist

  • All commits are signed (see Commit signing)
  • I reviewed the submitted code.
  • I added tests to verify the changes.
  • I updated the docs if needed.
  • No breaking change or entry added to the changelog.

If releasing new changes

  • Ran sampo add to generate a changeset file

🤖 Agent context

Autonomy: Human-driven (agent-assisted)

Written with Pi (Claude) and reviewed with the autoreview skill (GPT model, branch mode). Review found three real problems, which are fixed in separate commits. Validation consumed one-shot iterators before the /flags call. Unbounded iterables were read fully before the limit check. Non-string group types and None group lists were accepted. A fourth review run was clean.

capture keeps its existing error handling for invalid known-absent keys instead of raising. This matches how it already treats an invalid send_feature_flags value.

@github-actions

github-actions Bot commented Nov 19, 2026 •

Copy link
Copy Markdown
Contributor

SDK performance: posthog-python

3 changes worth reviewing: 3 observed regressions.

Flags require at least a 5% change in the median and all six pairs agreeing on direction. This is a noise filter, not proof of a performance change or a CI gate.

Test Measurement Before PR With PR Change
Evaluate a rollout flag Allocated memory per operation 14.89 KiB/op 15.77 KiB/op 5.9% more memory
Evaluate one boolean flag Allocated memory per operation 15.74 KiB/op 16.62 KiB/op 5.6% more memory
Evaluate a multivariate flag Allocated memory per operation 15.9 KiB/op 16.78 KiB/op 5.5% more memory
View all results
Test Measurement Before PR With PR Change Assessment
Capture and deliver events (32-byte payload, burst)
Shard: capture
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (32-byte payload, steady)
Shard: capture
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Queue an event (32-byte payload)
Shard: capture
Allocated memory per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Queue an event (32-byte payload)
Shard: capture
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Queue an event (4,096-byte payload)
Shard: capture
Allocated memory per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Queue an event (4,096-byte payload)
Shard: capture
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Refresh 1,000 flag definitions
Shard: flags-memory
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (32-byte payload, burst)
Shard: capture
Allocated memory per operation 133.67 KiB/op 133.79 KiB/op <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Allocations per operation 1,345.51 count/op 1,348.51 count/op 0.2% more Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Time per operation 77.19 µs/op 77.41 µs/op 0.3% more time Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Idle process memory (RSS) 37.59 MiB 37.6 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Observed peak process memory (RSS) 40.04 MiB 40.06 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Process memory after settling (RSS) 40.04 MiB 40.06 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Process CPU time per operation 81.18 µs/op 80.56 µs/op 0.8% less time Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Lifetime peak process memory (RSS) 40.36 MiB 40.36 MiB No observed change Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Allocated memory per operation 185.75 KiB/op 185.87 KiB/op <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Allocations per operation 1,337.51 count/op 1,340.51 count/op 0.2% more Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Time per operation 100.89 µs/op 100.66 µs/op 0.2% less time Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Idle process memory (RSS) 41.22 MiB 41.22 MiB <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Observed peak process memory (RSS) 47 MiB 47.02 MiB <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Process memory after settling (RSS) 47 MiB 47.02 MiB <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Process CPU time per operation 98.36 µs/op 98.19 µs/op 0.2% less time Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Lifetime peak process memory (RSS) 51.46 MiB 51.52 MiB 0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Allocated memory per operation 138.73 KiB/op 138.85 KiB/op <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Allocations per operation 1,390.3 count/op 1,393.3 count/op 0.2% more Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Time per operation 89.08 µs/op 88.62 µs/op 0.5% less time Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Idle process memory (RSS) 37.61 MiB 37.64 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Observed peak process memory (RSS) 37.79 MiB 37.82 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Process memory after settling (RSS) 37.79 MiB 37.82 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Process CPU time per operation 90.79 µs/op 90.28 µs/op 0.6% less time Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Lifetime peak process memory (RSS) 40.36 MiB 40.36 MiB No observed change Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Allocated memory per operation 190.9 KiB/op 191.02 KiB/op <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Allocations per operation 1,382.19 count/op 1,385.19 count/op 0.2% more Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Time per operation 106.45 µs/op 105.99 µs/op 0.4% less time Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Idle process memory (RSS) 41.11 MiB 41.1 MiB <0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Observed peak process memory (RSS) 41.57 MiB 41.6 MiB <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Process memory after settling (RSS) 41.18 MiB 41.18 MiB No observed change Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Process CPU time per operation 104.75 µs/op 100.05 µs/op 4.5% less time Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Lifetime peak process memory (RSS) 41.53 MiB 41.49 MiB <0.1% less memory Not flagged
Queue an event (32-byte payload)
Shard: capture
Caller-thread CPU time per operation 57.38 µs/op 57.68 µs/op 0.5% more time Not flagged
Queue an event (32-byte payload)
Shard: capture
Time per operation 57.37 µs/op 57.68 µs/op 0.5% more time Not flagged
Queue an event (4,096-byte payload)
Shard: capture
Caller-thread CPU time per operation 57.45 µs/op 57.5 µs/op <0.1% more time Not flagged
Queue an event (4,096-byte payload)
Shard: capture
Time per operation 57.45 µs/op 57.5 µs/op <0.1% more time Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Allocated memory per operation 225.43 KiB/op 226.35 KiB/op 0.4% more memory Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Allocations per operation 2,279.42 count/op 2,283.44 count/op 0.2% more Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Time per operation 83.04 µs/op 84.51 µs/op 1.8% more time Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Process CPU time per operation 83.04 µs/op 84.5 µs/op 1.8% more time Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Allocated memory per operation 2.17 MiB/op 2.17 MiB/op <0.1% more memory Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Allocations per operation 22,413.69 count/op 22,417.94 count/op <0.1% more Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Time per operation 775.63 µs/op 780.87 µs/op 0.7% more time Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Process CPU time per operation 775.39 µs/op 780.92 µs/op 0.7% more time Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Allocated memory per operation 21.63 MiB/op 21.64 MiB/op <0.1% more memory Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Allocations per operation 223,655.44 count/op 223,659.69 count/op <0.1% more Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Time per operation 7.7 ms/op 7.78 ms/op 1% more time Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Process CPU time per operation 7.7 ms/op 7.78 ms/op 1% more time Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Idle process memory (RSS) 43.8 MiB 43.88 MiB 0.2% more memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Observed peak process memory (RSS) 44.14 MiB 44.21 MiB 0.2% more memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Process memory after settling (RSS) 44.14 MiB 44.21 MiB 0.2% more memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Lifetime peak process memory (RSS) 43.87 MiB 43.98 MiB 0.3% more memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Idle process memory (RSS) 42.98 MiB 43 MiB <0.1% more memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Observed peak process memory (RSS) 42.99 MiB 43.01 MiB <0.1% more memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Process memory after settling (RSS) 42.99 MiB 43 MiB <0.1% more memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Lifetime peak process memory (RSS) 42.82 MiB 43.05 MiB 0.5% more memory Not flagged
Evaluate one boolean flag
Shard: flags-single
Allocated memory per operation 15.74 KiB/op 16.62 KiB/op 5.6% more memory Worth reviewing: observed regression
Evaluate one boolean flag
Shard: flags-single
Allocations per operation 162.77 count/op 167.77 count/op 3.1% more Not flagged
Evaluate one boolean flag
Shard: flags-single
Time per operation 8.29 µs/op 8.35 µs/op 0.8% more time Not flagged
Evaluate one boolean flag
Shard: flags-single
Process CPU time per operation 8.29 µs/op 8.35 µs/op 0.7% more time Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Allocated memory per operation 24.6 KiB/op 25.47 KiB/op 3.6% more memory Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Allocations per operation 239.28 count/op 244.28 count/op 2.1% more Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Time per operation 11.51 µs/op 11.93 µs/op 3.6% more time Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Process CPU time per operation 11.51 µs/op 11.93 µs/op 3.6% more time Not flagged
Evaluate a flag (early match)
Shard: flags-single
Allocated memory per operation 39.81 KiB/op 40.69 KiB/op 2.2% more memory Not flagged
Evaluate a flag (early match)
Shard: flags-single
Allocations per operation 388.27 count/op 393.27 count/op 1.3% more Not flagged
Evaluate a flag (early match)
Shard: flags-single
Time per operation 16.47 µs/op 16.81 µs/op 2% more time Not flagged
Evaluate a flag (early match)
Shard: flags-single
Process CPU time per operation 16.48 µs/op 16.81 µs/op 2% more time Not flagged
Evaluate a flag (late match)
Shard: flags-single
Allocated memory per operation 60.59 KiB/op 61.47 KiB/op 1.4% more memory Not flagged
Evaluate a flag (late match)
Shard: flags-single
Allocations per operation 584.27 count/op 589.27 count/op 0.9% more Not flagged
Evaluate a flag (late match)
Shard: flags-single
Time per operation 23.49 µs/op 24.22 µs/op 3.1% more time Not flagged
Evaluate a flag (late match)
Shard: flags-single
Process CPU time per operation 23.49 µs/op 24.22 µs/op 3.1% more time Not flagged
Evaluate a flag (no match)
Shard: flags-single
Allocated memory per operation 59.22 KiB/op 60.09 KiB/op 1.5% more memory Not flagged
Evaluate a flag (no match)
Shard: flags-single
Allocations per operation 567.77 count/op 572.77 count/op 0.9% more Not flagged
Evaluate a flag (no match)
Shard: flags-single
Time per operation 22.35 µs/op 22.76 µs/op 1.8% more time Not flagged
Evaluate a flag (no match)
Shard: flags-single
Process CPU time per operation 22.35 µs/op 22.76 µs/op 1.8% more time Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Allocated memory per operation 19.04 KiB/op 19.92 KiB/op 4.6% more memory Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Allocations per operation 192.27 count/op 197.27 count/op 2.6% more Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Time per operation 9.26 µs/op 9.43 µs/op 1.8% more time Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Process CPU time per operation 9.26 µs/op 9.43 µs/op 1.8% more time Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Allocated memory per operation 20.66 KiB/op 21.54 KiB/op 4.2% more memory Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Allocations per operation 197.77 count/op 202.77 count/op 2.5% more Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Time per operation 9.76 µs/op 10.04 µs/op 2.9% more time Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Process CPU time per operation 9.76 µs/op 10.04 µs/op 2.9% more time Not flagged
Evaluate a rollout flag
Shard: flags-single
Allocated memory per operation 14.89 KiB/op 15.77 KiB/op 5.9% more memory Worth reviewing: observed regression
Evaluate a rollout flag
Shard: flags-single
Allocations per operation 152.77 count/op 157.77 count/op 3.3% more Not flagged
Evaluate a rollout flag
Shard: flags-single
Time per operation 7.63 µs/op 7.85 µs/op 3% more time Not flagged
Evaluate a rollout flag
Shard: flags-single
Process CPU time per operation 7.63 µs/op 7.85 µs/op 3% more time Not flagged
Evaluate a multivariate flag
Shard: flags-single
Allocated memory per operation 15.9 KiB/op 16.78 KiB/op 5.5% more memory Worth reviewing: observed regression
Evaluate a multivariate flag
Shard: flags-single
Allocations per operation 166.77 count/op 171.77 count/op 3% more Not flagged
Evaluate a multivariate flag
Shard: flags-single
Time per operation 8.5 µs/op 8.63 µs/op 1.5% more time Not flagged
Evaluate a multivariate flag
Shard: flags-single
Process CPU time per operation 8.5 µs/op 8.63 µs/op 1.5% more time Not flagged

Values are medians of paired measurements. Not flagged does not mean unchanged. Unavailable means a measurement could not be provided, not zero. Estimated allocation measurements retain their instrumentation uncertainty. RSS measures the whole process, not just SDK allocations; observed peaks are sampled checkpoints. Paired ranges in the diagnostics describe variability, not confidence intervals.

Each shard uses its own runner; compare Before PR against With PR within a row, not across shards.

Compared 5994ff313c6dfb0cbbe3d29f367fb3b7c0a80a94 → 4772da33114b7fc2a4452b3b9f809a03868c09f0.

Full report and diagnostics

102 metric rows; 102 rows shown in all results. Omitted or shortened data remain in comparison.json, including per-runner environments, resource limits, measurement methods, samples and checkpoints.

@marandaneto
marandaneto marked this pull request as ready for review November 20, 2026 10:28
@marandaneto
marandaneto requested a review from a team as a code owner November 20, 2026 10:28
@veria-ai

veria-ai Bot commented Nov 20, 2026 •

Copy link
Copy Markdown

PR overview

No security issues were found in this pull request.

Reviews

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant