AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.
feat(platform): Sentry errors carry the feature flags that were on, recorded by the flag API (#14805)
Reinier van der Leerf4eb9610f2c6
diff --git a/autogpt_platform/backend/backend/util/feature_flag/__init__.py b/autogpt_platform/backend/backend/util/feature_flag/__init__.pyindex 1721f4f2e6..ffc1f9d563 100644--- a/autogpt_platform/backend/backend/util/feature_flag/__init__.py+++ b/autogpt_platform/backend/backend/util/feature_flag/__init__.py@@ -10,6 +10,7 @@ from functools import wrapsfrom typing import Any, Awaitable, Callable, TypeVarimport ldclient+import sentry_sdk.feature_flagsfrom autogpt_libs.auth.dependencies import get_optional_user_idfrom fastapi import HTTPException, Securityfrom ldclient import Context, LDClient@@ -518,10 +519,33 @@ async def _evaluate_flag_value(context = (_with_request_attributes(user_context, attributes), context_resolved)backend = settings.config.feature_flag_backendif backend is FeatureFlagBackend.POSTHOG:- return await _evaluate_posthog(flag_key, user_id, default, context)- if backend is FeatureFlagBackend.DUAL:- return await _evaluate_dual(flag_key, user_id, default, context)- return await _evaluate_launchdarkly(flag_key, user_id, default, context)+ result = await _evaluate_posthog(flag_key, user_id, default, context)+ elif backend is FeatureFlagBackend.DUAL:+ result = await _evaluate_dual(flag_key, user_id, default, context)+ else:+ result = await _evaluate_launchdarkly(flag_key, user_id, default, context)+ _record_flag_for_sentry(flag_key, *result)+ return result+++def _record_flag_for_sentry(flag_key: str, value: Any, evaluated: bool) -> None:+ """Put a served flag on Sentry's scope so errors show which flags were on,+ and which of them were a stand-in rather than the vendor's answer."""+ try:+ # Sentry's flag context holds booleans only; JSON and string flags are skipped.+ if not isinstance(value, bool):+ return+ sentry_sdk.feature_flags.add_feature_flag(flag_key, value)+ # A pseudo-flag on the scope's buffer only: a span keeps 10 flags and then+ # ignores every write, so there it would take a value's slot and never clear.+ flags = sentry_sdk.get_isolation_scope().flags+ marker = f"{flag_key}.fallback"+ if not evaluated:+ flags.set(marker, True)+ elif any(f["flag"] == marker for f in flags.get()):+ flags.set(marker, False)+ except Exception:+ logger.debug(f"Could not record flag {flag_key} for Sentry", exc_info=True)async def _evaluate_dual(@@ -861,6 +885,7 @@ async def evaluate_feature_flag(# A misconfigured flag is not an answer either: fall back to the default,# but never let a caller take an irreversible action on it.+ _record_flag_for_sentry(flag_key.value, default, False)return default, False@@ -903,6 +928,7 @@ def feature_flag(f"using default {flag_key}={repr(default)}")is_enabled = default+ _record_flag_for_sentry(flag_key, default, False)else:# Use the internal function directly since we have a raw string flag_keyflag_value = await get_feature_flag_value(@@ -919,6 +945,7 @@ def feature_flag(f"Using default value {repr(default)}")is_enabled = default+ _record_flag_for_sentry(flag_key, default, False)if not is_enabled:raise HTTPException(status_code=404, detail="Feature not available")@@ -989,6 +1016,7 @@ def create_feature_flag_dependency("Feature flag backend not configured, using default "f"{flag_key.value}={default}")+ _record_flag_for_sentry(flag_key.value, default, False)if not default:raise HTTPException(status_code=404, detail="Feature not available")return@@ -999,6 +1027,7 @@ def create_feature_flag_dependency("Feature flag backend not initialized, using default "f"{flag_key.value}={default}")+ _record_flag_for_sentry(flag_key.value, default, False)if not default:raise HTTPException(status_code=404, detail="Feature not available")returndiff --git a/autogpt_platform/backend/backend/util/feature_flag/backends_test.py b/autogpt_platform/backend/backend/util/feature_flag/backends_test.pyindex c978b13cdf..77eaf1857c 100644--- a/autogpt_platform/backend/backend/util/feature_flag/backends_test.py+++ b/autogpt_platform/backend/backend/util/feature_flag/backends_test.py@@ -7,11 +7,14 @@ import osimport uuidimport pytest+import sentry_sdk+import sentry_sdk.feature_flagsfrom fastapi import HTTPExceptionfrom ldclient import Context, LDClientfrom ldclient.config import Config as LDConfigfrom ldclient.integrations.test_data import TestDatafrom posthog import Posthog+from sentry_sdk.tracing import Spanimport backend.util.feature_flag as ffimport backend.util.feature_flag.posthog as ph@@ -691,6 +694,155 @@ class TestForcedFlagsInEveryBackend:assert off.value.status_code == 404+class TestSentryFlagContext:+ """Every vendor's served value lands on the scope Sentry attaches to errors."""++ @pytest.fixture+ def sentry_flags(self):+ with sentry_sdk.isolation_scope() as scope:+ # A forked scope inherits whatever earlier tests recorded.+ scope.flags.clear()+ yield scope.flags++ @pytest.mark.asyncio+ @pytest.mark.parametrize("backend", list(FeatureFlagBackend))+ async def test_a_boolean_flag_is_recorded_as_served(+ self, mocker, ld_client, user_context, sentry_flags, backend+ ):+ use_backend(mocker, backend)+ ld_client.variation.return_value = True+ stub_posthog(mocker, value=backend is FeatureFlagBackend.POSTHOG)++ assert await is_feature_enabled(Flag.HIRE_EXPERTS, "u-1") is True+ assert sentry_flags.get() == [{"flag": Flag.HIRE_EXPERTS.value, "result": True}]++ @pytest.mark.asyncio+ @pytest.mark.parametrize("initialized", [True, False])+ async def test_a_non_boolean_flag_records_nothing(+ self, ld_client, user_context, sentry_flags, initialized+ ):+ ld_client.is_initialized.return_value = initialized+ ld_client.variation.return_value = {"daily": 5}++ await ff.get_feature_flag_value("copilot-cost-limits", "u-1", {"daily": 1})+ assert sentry_flags.get() == []++ @pytest.mark.asyncio+ async def test_a_fallback_is_marked_beside_its_value(+ self, mocker, user_context, sentry_flags+ ):+ client = mocker.Mock(spec=LDClient)+ client.is_initialized.return_value = False+ mocker.patch("backend.util.feature_flag.ldclient.get", return_value=client)++ await is_feature_enabled(Flag.HIRE_EXPERTS, "u-1")++ assert sentry_flags.get() == [+ {"flag": Flag.HIRE_EXPERTS.value, "result": False},+ {"flag": f"{Flag.HIRE_EXPERTS.value}.fallback", "result": True},+ ]++ @pytest.mark.asyncio+ async def test_a_non_boolean_answer_to_a_boolean_read_records_the_default(+ self, ld_client, user_context, sentry_flags+ ):+ ld_client.variation.return_value = "on"++ assert await evaluate_feature_flag(Flag.HIRE_EXPERTS, "u-1", True) == (+ True,+ False,+ )+ assert sentry_flags.get() == [+ {"flag": Flag.HIRE_EXPERTS.value, "result": True},+ {"flag": f"{Flag.HIRE_EXPERTS.value}.fallback", "result": True},+ ]++ @pytest.mark.asyncio+ @pytest.mark.parametrize(+ "gate, configured, initialized, answer",+ [+ ("decorator", True, False, True),+ ("decorator", True, True, "on"),+ ("dependency", False, True, True),+ ("dependency", True, False, True),+ ],+ )+ async def test_a_gate_serving_its_default_records_it(+ self,+ mocker,+ ld_client,+ user_context,+ sentry_flags,+ gate,+ configured,+ initialized,+ answer,+ ):+ use_backend(mocker, FeatureFlagBackend.LAUNCHDARKLY)+ mocker.patch("backend.util.feature_flag.is_configured", return_value=configured)+ ld_client.is_initialized.return_value = initialized+ ld_client.variation.return_value = answer+ # A stale earlier answer must not be what an error from this route carries.+ sentry_sdk.feature_flags.add_feature_flag(Flag.HIRE_EXPERTS.value, True)++ with pytest.raises(HTTPException):+ if gate == "decorator":+ await _gated_route()(user_id="u-1")+ else:+ await ff.create_feature_flag_dependency(Flag.HIRE_EXPERTS)("u-1")++ assert {f["flag"]: f["result"] for f in sentry_flags.get()} == {+ Flag.HIRE_EXPERTS.value: False,+ f"{Flag.HIRE_EXPERTS.value}.fallback": True,+ }++ @pytest.mark.asyncio+ async def test_a_fallback_marker_stays_off_the_span(+ self, mocker, user_context, sentry_flags+ ):+ client = mocker.Mock(spec=LDClient)+ client.is_initialized.return_value = False+ mocker.patch("backend.util.feature_flag.ldclient.get", return_value=client)+ span = Span()+ scope = sentry_sdk.get_current_scope()+ previous, scope.span = scope.span, span+ try:+ await is_feature_enabled(Flag.HIRE_EXPERTS, "u-1")+ finally:+ scope.span = previous++ assert span._flags == {f"flag.evaluation.{Flag.HIRE_EXPERTS.value}": False}++ @pytest.mark.asyncio+ async def test_a_real_answer_clears_an_earlier_fallback(+ self, ld_client, user_context, sentry_flags+ ):+ sentry_sdk.feature_flags.add_feature_flag(+ f"{Flag.HIRE_EXPERTS.value}.fallback", True+ )+ ld_client.variation.return_value = True++ await is_feature_enabled(Flag.HIRE_EXPERTS, "u-1")++ assert {f["flag"]: f["result"] for f in sentry_flags.get()} == {+ f"{Flag.HIRE_EXPERTS.value}.fallback": False,+ Flag.HIRE_EXPERTS.value: True,+ }++ @pytest.mark.asyncio+ async def test_a_recording_failure_does_not_break_the_read(+ self, mocker, ld_client, user_context+ ):+ mocker.patch.object(+ sentry_sdk.feature_flags,+ "add_feature_flag",+ side_effect=RuntimeError("sentry down"),+ )+ ld_client.variation.return_value = True++ assert await evaluate_feature_flag(Flag.HIRE_EXPERTS, "u-1") == (True, True)++class TestTheCountryRuleInEveryBackend:"""The trial's country targeting, through each vendor's real evaluator."""diff --git a/autogpt_platform/backend/backend/util/metrics.py b/autogpt_platform/backend/backend/util/metrics.pyindex ee5eb51b1d..b16a54d1c3 100644--- a/autogpt_platform/backend/backend/util/metrics.py+++ b/autogpt_platform/backend/backend/util/metrics.py@@ -1,4 +1,3 @@-import loggingimport osimport reimport sys@@ -9,7 +8,6 @@ from pydantic import SecretStrfrom sentry_sdk._init_implementation import init as _sentry_initfrom sentry_sdk.api import capture_exception as _sentry_capture_exceptionfrom sentry_sdk.api import flush as _sentry_flush-from sentry_sdk.integrations import DidNotEnablefrom sentry_sdk.integrations.asyncio import AsyncioIntegrationfrom sentry_sdk.integrations.logging import LoggingIntegrationfrom sentry_sdk.scrubber import DEFAULT_DENYLIST, EventScrubber@@ -19,18 +17,11 @@ try:except ImportError:AnthropicIntegration = None # type: ignore[assignment,misc]-try:- from sentry_sdk.integrations.launchdarkly import LaunchDarklyIntegration-except ImportError:- LaunchDarklyIntegration = None # type: ignore[assignment,misc]--from backend.util import feature_flagfrom backend.util.exceptions import get_execution_failure_reasonfrom backend.util.security import SENSITIVE_FIELD_NAMESfrom backend.util.settings import BehaveAs, Settingssettings = Settings()-logger = logging.getLogger(__name__)class DiscordChannel(str, Enum):@@ -266,18 +257,6 @@ def sentry_init():returnsentry_dsn = settings.secrets.sentry_dsn- integrations = []- # Only wire the LaunchDarkly inspector where LaunchDarkly actually answers- # flag reads; in posthog mode this would build a client nothing else uses.- if (- feature_flag.serves_launchdarkly()- and feature_flag.is_configured()- and LaunchDarklyIntegration is not None- ):- try:- integrations.append(LaunchDarklyIntegration(feature_flag.get_client()))- except DidNotEnable as e:- logger.error(f"Error enabling LaunchDarklyIntegration for Sentry: {e}")optional_integrations = ([AnthropicIntegration(include_prompts=False)]if AnthropicIntegration is not None@@ -293,8 +272,7 @@ def sentry_init():AsyncioIntegration(),LoggingIntegration(),]- + optional_integrations- + integrations,+ + optional_integrations,)diff --git a/autogpt_platform/frontend/instrumentation-client.ts b/autogpt_platform/frontend/instrumentation-client.tsindex 67b6174e07..f59e281094 100644--- a/autogpt_platform/frontend/instrumentation-client.ts+++ b/autogpt_platform/frontend/instrumentation-client.ts@@ -33,7 +33,7 @@ Sentry.init({Sentry.extraErrorDataIntegration(),Sentry.browserProfilingIntegration(),Sentry.httpClientIntegration(),- Sentry.launchDarklyIntegration(),+ Sentry.featureFlagsIntegration(),Sentry.replayIntegration({unmask: [".sentry-unmask, [data-sentry-unmask]"],}),diff --git a/autogpt_platform/frontend/src/__tests__/instrumentation-client.test.ts b/autogpt_platform/frontend/src/__tests__/instrumentation-client.test.tsindex d7a60e7491..405dd03ac9 100644--- a/autogpt_platform/frontend/src/__tests__/instrumentation-client.test.ts+++ b/autogpt_platform/frontend/src/__tests__/instrumentation-client.test.ts@@ -20,7 +20,7 @@ vi.mock("@sentry/nextjs", () => {extraErrorDataIntegration: stubIntegration("ExtraErrorData"),browserProfilingIntegration: stubIntegration("BrowserProfiling"),httpClientIntegration: stubIntegration("HttpClient"),- launchDarklyIntegration: stubIntegration("LaunchDarkly"),+ featureFlagsIntegration: stubIntegration("FeatureFlags"),replayIntegration: stubIntegration("Replay"),replayCanvasIntegration: stubIntegration("ReplayCanvas"),captureRouterTransitionStart: vi.fn(),diff --git a/autogpt_platform/frontend/src/services/feature-flags/__tests__/flag-backends.test.tsx b/autogpt_platform/frontend/src/services/feature-flags/__tests__/flag-backends.test.tsxindex 41756582a0..976a3ba547 100644--- a/autogpt_platform/frontend/src/services/feature-flags/__tests__/flag-backends.test.tsx+++ b/autogpt_platform/frontend/src/services/feature-flags/__tests__/flag-backends.test.tsx@@ -1,4 +1,5 @@-import { renderHook } from "@testing-library/react";+import { render, renderHook } from "@testing-library/react";+import { Component, type ReactNode } from "react";import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";const launchDarkly = vi.hoisted(() => ({@@ -43,6 +44,17 @@ vi.mock("@posthog/react", () => ({usePostHog: () => postHogClient,}));+const sentry = vi.hoisted(() => ({ addFeatureFlag: vi.fn() }));++vi.mock("@sentry/nextjs", () => ({+ getClient: () => ({+ getIntegrationByName: (name: string) =>+ name === "FeatureFlags"+ ? { addFeatureFlag: sentry.addFeatureFlag }+ : undefined,+ }),+}));+vi.mock("@/app/(platform)/marketplace/components/HeroSection/helpers", () => ({DEFAULT_SEARCH_TERMS: [],}));@@ -337,6 +349,106 @@ describe("dual backend", () => {});});+describe("Sentry's flag context", () => {+ it.each([+ ["launchdarkly", undefined],+ ["posthog", "posthog"],+ ["dual", "dual"],+ ])("records the served boolean in %s mode", async (_, backend) => {+ const { Flag, useFlagStatus } = await loadWithBackend(backend);+ vi.spyOn(console, "warn").mockImplementation(() => {});+ launchDarkly.flags = { [HIRE_EXPERTS]: true };+ postHog.enabled.mockReturnValue(backend === "posthog");++ renderHook(() => useFlagStatus(Flag.HIRE_EXPERTS));++ expect(sentry.addFeatureFlag).toHaveBeenCalledExactlyOnceWith(+ HIRE_EXPERTS,+ true,+ );+ });++ it("records a flag read by a component that throws in the same render", async () => {+ const { Flag, useGetFlag } = await loadWithBackend(undefined);+ vi.spyOn(console, "error").mockImplementation(() => {});+ launchDarkly.flags = { [HIRE_EXPERTS]: true };+ let recordedAtCatch: unknown[][] = [];+ function Reader(): ReactNode {+ useGetFlag(Flag.HIRE_EXPERTS);+ throw new Error("render failed");+ }+ class Boundary extends Component<{ children: ReactNode }> {+ state = { failed: false };+ static getDerivedStateFromError() {+ return { failed: true };+ }+ componentDidCatch() {+ recordedAtCatch = [...sentry.addFeatureFlag.mock.calls];+ }+ render() {+ return this.state.failed ? null : this.props.children;+ }+ }++ render(+ <Boundary>+ <Reader />+ </Boundary>,+ );++ expect(recordedAtCatch).toContainEqual([HIRE_EXPERTS, true]);+ });++ it("records the default it serves while flags are disabled", async () => {+ env.launchDarklyEnabled = false;+ const { Flag, useGetFlag } = await loadWithBackend(undefined);+ launchDarkly.flags = { [HIRE_EXPERTS]: true };++ const { result } = renderHook(() => useGetFlag(Flag.HIRE_EXPERTS));++ expect(result.current).toBe(false);+ expect(sentry.addFeatureFlag).toHaveBeenCalledExactlyOnceWith(+ HIRE_EXPERTS,+ false,+ );+ });++ it("records nothing for an env-forced flag", async () => {+ const { Flag, useFlagStatus, useGetFlag } =+ await loadWithBackend(undefined);+ process.env.NEXT_PUBLIC_FORCE_FLAG_HIRE_EXPERTS = "true";++ renderHook(() => useFlagStatus(Flag.HIRE_EXPERTS));+ renderHook(() => useGetFlag(Flag.HIRE_EXPERTS));++ expect(sentry.addFeatureFlag).not.toHaveBeenCalled();+ });++ it("records nothing for a JSON-valued flag", async () => {+ const { Flag, useGetFlag } = await loadWithBackend(undefined);+ launchDarkly.flags = { "copilot-bot-platforms": { slack: false } };++ renderHook(() => useGetFlag(Flag.COPILOT_BOT_PLATFORMS));++ expect(sentry.addFeatureFlag).not.toHaveBeenCalled();+ });++ it("still serves the flag when recording throws", async () => {+ const { Flag, useGetFlag } = await loadWithBackend(undefined);+ sentry.addFeatureFlag.mockImplementation(() => {+ throw new Error("sentry down");+ });+ launchDarkly.flags = { [HIRE_EXPERTS]: true };++ const debug = vi.spyOn(console, "debug").mockImplementation(() => {});++ const { result } = renderHook(() => useGetFlag(Flag.HIRE_EXPERTS));++ expect(result.current).toBe(true);+ expect(debug).toHaveBeenCalledOnce();+ });+});+describe("posthog flags follow the provider's gate", () => {it("falls back to defaults outside cloud, where no PostHogProvider mounts", async () => {process.env.NEXT_PUBLIC_BEHAVE_AS = "LOCAL";@@ -358,6 +470,7 @@ beforeEach(() => {postHog.enabled.mockReturnValue(undefined);postHog.payload.mockReturnValue(undefined);postHog.capture.mockClear();+ sentry.addFeatureFlag.mockReset();postHog.loaded = true;postHog.errorsLoading = false;Object.keys(process.env)diff --git a/autogpt_platform/frontend/src/services/feature-flags/__tests__/ld-init-timeout.test.tsx b/autogpt_platform/frontend/src/services/feature-flags/__tests__/ld-init-timeout.test.tsxindex 82fb4939e2..bcb4bf9c11 100644--- a/autogpt_platform/frontend/src/services/feature-flags/__tests__/ld-init-timeout.test.tsx+++ b/autogpt_platform/frontend/src/services/feature-flags/__tests__/ld-init-timeout.test.tsx@@ -12,17 +12,22 @@ import { Flag, useGetFlag } from "../use-get-flag";// floods Sentry on every page load and never really times out.const LD_HIGH_TIMEOUT_THRESHOLD_SECONDS = 5;-const ld = vi.hoisted(() => ({ timeouts: [] as unknown[] }));+const ld = vi.hoisted(() => ({+ timeouts: [] as unknown[],+ options: [] as unknown[],+}));interface Props {timeout?: number;+ options?: unknown;children: ReactNode;}vi.mock("launchdarkly-react-client-sdk", () => {// Declared inside the factory: vi.mock is hoisted above module scope.- function MockLDProvider({ timeout, children }: Props) {+ function MockLDProvider({ timeout, options, children }: Props) {ld.timeouts.push(timeout);+ ld.options.push(options);return <>{children}</>;}return {@@ -49,10 +54,6 @@ vi.mock("@/app/(platform)/marketplace/components/HeroSection/helpers", () => ({DEFAULT_SEARCH_TERMS: [],}));-vi.mock("@sentry/nextjs", () => ({- buildLaunchDarklyFlagUsedHandler: () => ({}),-}));-function FlagProbe() {const enabled = useGetFlag(Flag.ENABLE_PLATFORM_PAYMENT);return <span>payment: {String(enabled)}</span>;@@ -81,4 +82,14 @@ describe("LaunchDarkly initialisation timeout", () => {expect(screen.getByText("payment: false")).toBeDefined();});++ it("wires no LaunchDarkly-only Sentry inspector; the flag seam records for every vendor", () => {+ render(+ <LaunchDarklyProvider>+ <FlagProbe />+ </LaunchDarklyProvider>,+ );++ expect(ld.options.at(-1)).toBeUndefined();+ });});diff --git a/autogpt_platform/frontend/src/services/feature-flags/__tests__/sentry-integration-name.test.ts b/autogpt_platform/frontend/src/services/feature-flags/__tests__/sentry-integration-name.test.tsnew file mode 100644index 0000000000..ecbfc37c03--- /dev/null+++ b/autogpt_platform/frontend/src/services/feature-flags/__tests__/sentry-integration-name.test.ts@@ -0,0 +1,10 @@+import { featureFlagsIntegration } from "@sentry/nextjs";+import { describe, expect, test } from "vitest";++// The hooks look the integration up by this name; the other flag tests mock+// @sentry/nextjs, so only this one reads it off the real SDK.+describe("Sentry flag recording", () => {+ test("the SDK's feature-flag integration carries the name the hooks look up", () => {+ expect(featureFlagsIntegration().name).toBe("FeatureFlags");+ });+});diff --git a/autogpt_platform/frontend/src/services/feature-flags/feature-flag-provider.tsx b/autogpt_platform/frontend/src/services/feature-flags/feature-flag-provider.tsxindex 95acff35ca..83105895e6 100644--- a/autogpt_platform/frontend/src/services/feature-flags/feature-flag-provider.tsx+++ b/autogpt_platform/frontend/src/services/feature-flags/feature-flag-provider.tsx@@ -2,7 +2,6 @@import { LoadingSpinner } from "@/components/atoms/LoadingSpinner/LoadingSpinner";import { useAuth } from "@/lib/auth/hooks/useAuth";-import * as Sentry from "@sentry/nextjs";import { LDProvider } from "launchdarkly-react-client-sdk";import type { ReactNode } from "react";import { useMemo } from "react";@@ -36,9 +35,6 @@ export function LaunchDarklyProvider({ children }: { children: ReactNode }) {context={context}timeout={LD_INIT_TIMEOUT_SECONDS}reactOptions={{ useCamelCaseFlagKeys: false }}- options={{- inspectors: [Sentry.buildLaunchDarklyFlagUsedHandler()],- }}>{children}</LDProvider>diff --git a/autogpt_platform/frontend/src/services/feature-flags/use-get-flag.ts b/autogpt_platform/frontend/src/services/feature-flags/use-get-flag.tsindex b2ee3c5eb9..35f2808518 100644--- a/autogpt_platform/frontend/src/services/feature-flags/use-get-flag.ts+++ b/autogpt_platform/frontend/src/services/feature-flags/use-get-flag.ts@@ -2,6 +2,8 @@import { DEFAULT_SEARCH_TERMS } from "@/app/(platform)/marketplace/components/HeroSection/helpers";import { environment } from "@/services/environment";+import * as Sentry from "@sentry/nextjs";+import type { FeatureFlagsIntegration } from "@sentry/nextjs";import { useEffect, useState } from "react";import { FLAG_BACKEND, isPostHogFlagsEnabled } from "./flag-backend";import { useFlagSource } from "./flag-source";@@ -204,18 +206,10 @@ export function envFlagOverride<T extends Flag>(export function useGetFlag<T extends Flag>(flag: T): FlagValues[T] {const { value } = useFlagSource(flag);- const areFlagsEnabled = areFeatureFlagsEnabled();-const override = envFlagOverride(flag);- if (override !== undefined) {- return override;- }-- if (!areFlagsEnabled || isPwMockEnabled) {- return defaultFlags[flag];- }-- return resolveFlagValue(flag, value);+ const served = override ?? servedFlagValue(flag, value);+ recordFlagForSentry(flag, override === undefined ? served : undefined);+ return served;}const FLAG_RESOLUTION_TIMEOUT_MS = 5000;@@ -245,20 +239,24 @@ export function useFlagStatus<T extends Flag>(return () => clearTimeout(timer);}, []);- if (override !== undefined) {- return { enabled: override, ready: true, answered: true };- }- if (!areFlagsEnabled || isPwMockEnabled) {- return { enabled: defaultFlags[flag], ready: true, answered: true };- }+ const served = override ?? servedFlagValue(flag, value);+ recordFlagForSentry(flag, override === undefined ? served : undefined);+ if (override !== undefined || !areFlagsEnabled || isPwMockEnabled) {+ return { enabled: served, ready: true, answered: true };+ }return {- enabled: resolveFlagValue(flag, value),+ enabled: served,ready: resolved || timedOut,answered: resolved,};}+function servedFlagValue<T extends Flag>(flag: T, value: unknown) {+ if (!areFeatureFlagsEnabled() || isPwMockEnabled) return defaultFlags[flag];+ return resolveFlagValue(flag, value);+}+// PostHog answers a flag with no payload as a bare boolean, so a JSON-valued// flag can arrive as `true` and reach a consumer that calls `.map` on it.// `typeof` alone can't separate an array from an object; both are "object".@@ -295,3 +293,20 @@ function areFeatureFlagsEnabled() {return environment.areFeatureFlagsEnabled();}}++// Records the value served, not the vendor's; env overrides pass undefined.+// Called during render, not in an effect: a component that throws in the same+// render never commits, and its error would reach Sentry without the flag.+// Sentry's flag context holds booleans only; JSON-valued flags are skipped.+// A recording failure must never break a flag read.+function recordFlagForSentry(key: string, value: unknown) {+ if (typeof value !== "boolean") return;+ try {+ Sentry.getClient()+ ?.getIntegrationByName<FeatureFlagsIntegration>("FeatureFlags")+ ?.addFeatureFlag(key, value);+ } catch (error) {+ // Debug, not warn: captureConsoleIntegration would send it to Sentry.+ console.debug(`Could not record flag ${key} for Sentry`, error);+ }+}