Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(signals): emit inbox signals for firing alerts without investigation (#128957)

posthog[bot]c443dcb5ad27
diff --git a/frontend/src/lib/signals/signalCardSourceLine.ts b/frontend/src/lib/signals/signalCardSourceLine.ts
index 5d251b016783..dd766ac467d5 100644
--- a/frontend/src/lib/signals/signalCardSourceLine.ts
+++ b/frontend/src/lib/signals/signalCardSourceLine.ts
@@ -19,6 +19,28 @@ export function scoutDisplayName(skillName: string | null | undefined): string |
return rest.charAt(0).toUpperCase() + rest.slice(1)
}
+// Products whose every signal type reads the same.
+const SOURCE_LINE_BY_PRODUCT = new Map<string, string>([
+ ['session_replay', 'Session replay · Problem segment'],
+ ['replay_vision', 'Replay vision · Scanner finding'],
+ ['health_checks', 'Health checks · Instrumentation issue'],
+])
+
+// Keyed `${source_product}/${source_type}`.
+const SOURCE_LINE_BY_PAIR = new Map<string, string>([
+ ['llm_analytics/evaluation', 'AI observability · Evaluation'],
+ ['llm_analytics/evaluation_report', 'AI observability · Evaluation report'],
+ ['zendesk/ticket', 'Zendesk · Ticket'],
+ ['github/issue', 'GitHub · Issue'],
+ ['linear/issue', 'Linear · Issue'],
+ ['conversations/ticket', 'Conversations · Ticket'],
+ ['pganalyze/issue', 'pganalyze · Issue'],
+ ['endpoints/endpoint_execution_failed', 'Endpoints · Endpoint execution failed'],
+ ['logs/alert_state_change', 'Logs · Alert state change'],
+ ['analytics/anomaly_investigation', 'Product analytics · Anomaly investigation'],
+ ['analytics/alert_firing', 'Product analytics · Alert firing'],
+])
+
/** Human-readable "Product · Signal type" line for inbox / debug signal cards. */
export function signalCardSourceLine(signal: { source_product: string; source_type: string; extra?: unknown }): string {
const { source_product, source_type } = signal
@@ -26,51 +48,17 @@ export function signalCardSourceLine(signal: { source_product: string; source_ty
if (source_product === 'error_tracking') {
return errorTrackingSignalHeaderLine(source_type)
}
- if (source_product === 'session_replay') {
- return 'Session replay · Problem segment'
- }
- if (source_product === 'replay_vision') {
- return 'Replay vision · Scanner finding'
- }
- if (source_product === 'llm_analytics' && source_type === 'evaluation') {
- return 'AI observability · Evaluation'
- }
- if (source_product === 'llm_analytics' && source_type === 'evaluation_report') {
- return 'AI observability · Evaluation report'
- }
- if (source_product === 'zendesk' && source_type === 'ticket') {
- return 'Zendesk · Ticket'
- }
- if (source_product === 'github' && source_type === 'issue') {
- return 'GitHub · Issue'
- }
- if (source_product === 'linear' && source_type === 'issue') {
- return 'Linear · Issue'
- }
- if (source_product === 'conversations' && source_type === 'ticket') {
- return 'Conversations · Ticket'
- }
- if (source_product === 'pganalyze' && source_type === 'issue') {
- return 'pganalyze · Issue'
- }
- if (source_product === 'endpoints' && source_type === 'endpoint_execution_failed') {
- return 'Endpoints · Endpoint execution failed'
- }
- if (source_product === 'logs' && source_type === 'alert_state_change') {
- return 'Logs · Alert state change'
- }
- if (source_product === 'analytics' && source_type === 'anomaly_investigation') {
- return 'Product analytics · Anomaly investigation'
- }
- if (source_product === 'health_checks') {
- return 'Health checks · Instrumentation issue'
- }
if (source_product === 'signals_scout') {
const extra = signal.extra as { skill_name?: unknown } | undefined
const skillName = typeof extra?.skill_name === 'string' ? extra.skill_name : undefined
const name = scoutDisplayName(skillName)
return name ? `Scout · ${name}` : 'Scout · Cross-source finding'
}
+ const known =
+ SOURCE_LINE_BY_PRODUCT.get(source_product) ?? SOURCE_LINE_BY_PAIR.get(`${source_product}/${source_type}`)
+ if (known) {
+ return known
+ }
const productLabel = source_product.replace(/_/g, ' ')
const typeLabel = source_type.replace(/_/g, ' ')
diff --git a/posthog/temporal/alerts/activities.py b/posthog/temporal/alerts/activities.py
index c5339654dbf8..929e7c969b49 100644
--- a/posthog/temporal/alerts/activities.py
+++ b/posthog/temporal/alerts/activities.py
@@ -60,6 +60,11 @@ from posthog.temporal.alerts.admission import (
release_evaluation_slot,
release_evaluation_slots,
)
+from posthog.temporal.alerts.alert_firing_signal import (
+ AlertFiringSignal,
+ dispatch_alert_firing_signal,
+ prepare_alert_firing_signal,
+)
from posthog.temporal.alerts.investigation import (
carried_verdict_suppresses,
claim_investigation_slot,
@@ -642,12 +647,15 @@ async def evaluate_alert(inputs: EvaluateAlertActivityInputs) -> EvaluateAlertRe
# replaced learns it only on its next slot refresh, so a query that finishes before then still
# records.
stopping = threading.Event()
+ # Set by the evaluation thread, and dispatched once that thread returns.
+ firing_signal: AlertFiringSignal | None = None
def _stop_if_cancelled() -> None:
if stopping.is_set():
raise _EvaluationStopped()
def _evaluate(alert: AlertConfiguration) -> EvaluateAlertResult:
+ nonlocal firing_signal
_stop_if_cancelled()
evaluated_alert = alert
evaluated_fingerprint = _evaluation_fingerprint(alert)
@@ -783,6 +791,9 @@ async def evaluate_alert(inputs: EvaluateAlertActivityInputs) -> EvaluateAlertRe
# recorded on the check and can't affect the alert outcome.
if should_run_metrics_investigation:
run_metrics_alert_investigation(alert, alert_check)
+ firing_signal = prepare_alert_firing_signal(
+ alert, alert_check, previous_state=previous_state, breaches=breaches
+ )
return EvaluateAlertResult(
alert_check_id=str(alert_check.id),
@@ -817,7 +828,11 @@ async def evaluate_alert(inputs: EvaluateAlertActivityInputs) -> EvaluateAlertRe
thread = asyncio.ensure_future(
database_sync_to_async(_evaluate, thread_sensitive=False, executor=executor)(alert)
)
- return await asyncio.shield(thread)
+ result = await asyncio.shield(thread)
+ if firing_signal is not None:
+ # Here, not in the thread: emit_signal needs the default executor that the thread runs on.
+ await dispatch_alert_firing_signal(firing_signal)
+ return result
timeouts = alert_timeouts(inputs.calculation_interval)
diff --git a/posthog/temporal/alerts/alert_firing_signal.py b/posthog/temporal/alerts/alert_firing_signal.py
new file mode 100644
index 000000000000..db2258596627
--- /dev/null
+++ b/posthog/temporal/alerts/alert_firing_signal.py
@@ -0,0 +1,237 @@
+"""Inbox signals for insight alerts that start to fire without the investigation agent.
+
+The investigation agent emits its own `analytics` / `anomaly_investigation` signal after the verdict.
+This path covers the alerts it never investigates, for teams whose product analytics source has the
+`all_firing_alerts` scope. It emits one signal per firing episode, from the check that starts it.
+"""
+
+from __future__ import annotations
+
+import enum
+import asyncio
+
+import structlog
+
+from posthog.schema import AlertState
+
+from posthog.dataclasses import frozen
+from posthog.models import Team
+from posthog.temporal.alerts.investigation import investigates
+from posthog.token_bucket import BucketUnavailable, Budget, consume, refund
+from posthog.utils import absolute_uri
+
+from products.alerts.backend.models.alert import AlertCheck, AlertConfiguration
+from products.signals.backend.facade.api import emit_signal
+from products.signals.backend.facade.signal_extras import AnalyticsAlertFiringSignalExtra
+from products.signals.backend.facade.source_configs import get_analytics_alert_scope, get_source_config
+
+logger = structlog.get_logger(__name__)
+
+SIGNAL_SOURCE_PRODUCT = "analytics"
+SIGNAL_SOURCE_TYPE = "alert_firing"
+# The product analytics source row. Its `enabled` flag and `alert_scope` key govern this signal too.
+_SOURCE_CONFIG_TYPE = "anomaly_investigation"
+_ALL_FIRING_ALERTS = "all_firing_alerts"
+
+# Rollout cap per team: a burst of 20 episodes, then about one per hour. Each signal costs a pipeline
+# run, and a team with many noisy alerts must not flood its inbox or our spend.
+CAP_BUDGET = Budget(burst=20, per_hour=1)
+
+# Same margin under the facade's description token limit as the investigation signal.
+_MAX_DESCRIPTION_CHARS = 3000
+_MAX_BREACHES = 20
+
+
+class AlertFiringSkipReason(enum.StrEnum):
+ NOT_NEW_EPISODE = "not_new_episode"
+ INVESTIGATED = "investigated"
+ SOURCE_DISABLED = "source_disabled"
+ SCOPE = "scope"
+ CAP = "cap"
+ CAP_UNAVAILABLE = "cap_unavailable"
+ NOT_DISPATCHED = "not_dispatched"
+
+
+# Nearly every check fails one of these, so a log line for them would only be noise.
+_UNLOGGED_SKIP_REASONS = frozenset({AlertFiringSkipReason.NOT_NEW_EPISODE, AlertFiringSkipReason.INVESTIGATED})
+
+
+def cap_key(team_id: int) -> str:
+ return f"signals_alert_firing_rate:{team_id}"
+
+
+def alert_firing_skip_reason(
+ alert: AlertConfiguration, *, previous_state: str, new_state: str
+) -> AlertFiringSkipReason | None:
+ """The in-memory gates. They run before any read, because most checks fail them."""
+ if new_state != AlertState.FIRING or previous_state == AlertState.FIRING:
+ return AlertFiringSkipReason.NOT_NEW_EPISODE
+ if investigates(alert, firing=True):
+ # The agent's verdict decides for these alerts, in both scopes.
+ return AlertFiringSkipReason.INVESTIGATED
+ return None
+
+
+@frozen
+class AlertFiringSignal:
+ """A signal that passed every gate and charged the cap, ready to dispatch."""
+
+ team: Team
+ alert_id: str
+ alert_check_id: str
+ description: str
+ extra: dict
+
+
+def prepare_alert_firing_signal(
+ alert: AlertConfiguration, alert_check: AlertCheck, *, previous_state: str, breaches: list[str] | None
+) -> AlertFiringSignal | None:
+ """Run the gates and build the signal, or return None to skip it. Never raises.
+
+ Call it in the evaluation thread, after the check is committed and outside the alert row lock.
+ It charges the cap, and `dispatch_alert_firing_signal` refunds the charge when nothing is sent.
+ """
+ try:
+ skip_reason, signal = _prepare(alert, alert_check, previous_state=previous_state, breaches=breaches or [])
+ except Exception:
+ logger.exception(
+ "alert_firing.signal_prepare_failed", alert_id=str(alert.id), alert_check_id=str(alert_check.id)
+ )
+ return None
+ if skip_reason is not None and skip_reason not in _UNLOGGED_SKIP_REASONS:
+ _log_skip(str(alert.id), str(alert_check.id), skip_reason)
+ return signal
+
+
+async def dispatch_alert_firing_signal(signal: AlertFiringSignal) -> bool:
+ """Send a prepared signal. Returns whether it was dispatched. Never raises.
+
+ Await it from the activity's event loop after the evaluation thread returns. `emit_signal` runs
+ sync work on the default executor, so a call that blocks an evaluation thread on it can deadlock
+ once every executor thread waits the same way. A failure never changes the committed check.
+ """
+ source_id = f"{signal.alert_id}:{signal.alert_check_id}"
+ try:
+ dispatched = await emit_signal(
+ team=signal.team,
+ source_product=SIGNAL_SOURCE_PRODUCT,
+ source_type=SIGNAL_SOURCE_TYPE,
+ source_id=source_id,
+ # Same key on a retried evaluation, so one episode starts at most one emission.
+ idempotency_key=source_id,
+ description=signal.description,
+ weight=1,
+ extra=signal.extra,
+ )
+ except Exception:
+ logger.exception(
+ "alert_firing.signal_emission_failed", alert_id=signal.alert_id, alert_check_id=signal.alert_check_id
+ )
+ dispatched = None
+ if dispatched:
+ logger.info("alert_firing.signal_emitted", alert_id=signal.alert_id, alert_check_id=signal.alert_check_id)
+ return True
+ await asyncio.to_thread(refund, cap_key(signal.team.id), CAP_BUDGET)
+ if dispatched is False:
+ _log_skip(signal.alert_id, signal.alert_check_id, AlertFiringSkipReason.NOT_DISPATCHED)
+ return False
+
+
+def _log_skip(alert_id: str, alert_check_id: str, reason: AlertFiringSkipReason) -> None:
+ logger.info("alert_firing.signal_skipped", alert_id=alert_id, alert_check_id=alert_check_id, reason=reason.value)
+
+
+def _resumes_interrupted_episode(alert: AlertConfiguration, alert_check: AlertCheck) -> bool:
+ """Whether the checks before this one, ignoring errored checks, end in a firing check.
+
+ A failed query says nothing about the metric. Without this read, a transient error during an
+ incident would look like a new firing episode, and the incident would file a second signal.
+ """
+ last_state = (
+ AlertCheck.objects.filter(alert_configuration=alert)
+ .exclude(id=alert_check.id)
+ .exclude(state=AlertState.ERRORED)
+ .order_by("-created_at")
+ .values_list("state", flat=True)
+ .first()
+ )
+ return last_state == AlertState.FIRING
+
+
+def _prepare(
+ alert: AlertConfiguration, alert_check: AlertCheck, *, previous_state: str, breaches: list[str]
+) -> tuple[AlertFiringSkipReason | None, AlertFiringSignal | None]:
+ skip_reason = alert_firing_skip_reason(alert, previous_state=previous_state, new_state=alert_check.state)
+ if skip_reason is not None:
+ return skip_reason, None
+ source = get_source_config(
+ team_id=alert.team_id, source_product=SIGNAL_SOURCE_PRODUCT, source_type=_SOURCE_CONFIG_TYPE
+ )
+ if source is None or not source.enabled:
+ return AlertFiringSkipReason.SOURCE_DISABLED, None
+ if get_analytics_alert_scope(team_id=alert.team_id) != _ALL_FIRING_ALERTS:
+ return AlertFiringSkipReason.SCOPE, None
+ if previous_state == AlertState.ERRORED and _resumes_interrupted_episode(alert, alert_check):
+ return AlertFiringSkipReason.NOT_NEW_EPISODE, None
+
+ team = alert.team
+ # `emit_signal` reads the organization for its consent gate. Loading it here keeps that read off the event loop.
+ team.organization # noqa: B018
+ signal = AlertFiringSignal(
+ team=team,
+ alert_id=str(alert.id),
+ alert_check_id=str(alert_check.id),
+ description=build_signal_description(alert, breaches),
+ extra=build_signal_extra(alert, alert_check, breaches),
+ )
+ # Charged last, so a failure above spends no token.
+ decision = consume(cap_key(alert.team_id), CAP_BUDGET)
+ if isinstance(decision, BucketUnavailable):
+ # Fails closed: the cap exists to bound spend during the rollout, and the signal is best effort.
+ return AlertFiringSkipReason.CAP_UNAVAILABLE, None
+ if not decision.allowed:
+ return AlertFiringSkipReason.CAP, None
+ return None, signal
+
+
+def _detector_type(alert: AlertConfiguration) -> str:
+ return (alert.detector_config or {}).get("type") or "threshold"
+
+
+def build_signal_extra(alert: AlertConfiguration, alert_check: AlertCheck, breaches: list[str]) -> dict:
+ insight = alert.insight
+ triggered_dates = alert_check.triggered_dates
+ extra = AnalyticsAlertFiringSignalExtra(
+ alert_id=str(alert.id),
+ alert_name=alert.name or "Unnamed alert",
+ insight_id=str(insight.id),
+ alert_check_id=str(alert_check.id),
+ detector_type=_detector_type(alert),
+ breaches=breaches[:_MAX_BREACHES],
+ episode_started_at=alert_check.created_at.isoformat(),
+ url=absolute_uri(f"/project/{alert.team_id}/insights/{insight.short_id}?alert_id={alert.id}"),
+ insight_name=insight.name or None,
+ insight_short_id=insight.short_id or None,
+ triggered_dates=(
+ [str(date) for date in triggered_dates] if isinstance(triggered_dates, list) and triggered_dates else None
+ ),
+ )
+ return extra.model_dump(exclude_none=True)
+
+
+def build_signal_description(alert: AlertConfiguration, breaches: list[str]) -> str:
+ """Human-readable text embedded for grouping. It names the alert and the insight, then the breaches."""
+ insight = alert.insight
+ metric = f" on {insight.name}" if insight.name else ""
+ insight_ref = f"{insight.short_id} / id {insight.id}" if insight.short_id else f"id {insight.id}"
+ lines = [
+ f"Insight alert '{alert.name or 'Unnamed alert'}'{metric} started firing.",
+ f"Insight: {insight_ref}. Detector: {_detector_type(alert)}.",
+ ]
+ if breaches:
+ lines.append("Breaches:")
+ lines.extend(f"- {breach}" for breach in breaches[:_MAX_BREACHES])
+ description = "\n".join(lines)
+ if len(description) > _MAX_DESCRIPTION_CHARS:
+ description = description[: _MAX_DESCRIPTION_CHARS - 1].rstrip() + "…"
+ return description
diff --git a/posthog/temporal/tests/test_alerts_activities.py b/posthog/temporal/tests/test_alerts_activities.py
index c71f3be8f40b..d1eccc148b27 100644
--- a/posthog/temporal/tests/test_alerts_activities.py
+++ b/posthog/temporal/tests/test_alerts_activities.py
@@ -9,7 +9,7 @@ from datetime import UTC, datetime, timedelta
import pytest
import time_machine
-from unittest.mock import MagicMock, call, patch
+from unittest.mock import AsyncMock, MagicMock, call, patch
from django.core.exceptions import ValidationError
from django.db import OperationalError, connection, transaction
@@ -97,6 +97,7 @@ from products.alerts.backend.models.alert import AlertCheck, AlertConfiguration,
from products.alerts_platform.backend.facade.contracts import AlertDelivery
from products.alerts_platform.backend.facade.enums import PlatformAlertOwner
from products.product_analytics.backend.facade.models import Insight
+from products.signals.backend.facade.source_configs import SignalSourceConfigSnapshot
def _email_delivery(target: str, at: str = "2026-08-11T00:00:00+00:00") -> AlertDelivery:
@@ -1021,14 +1022,49 @@ class TestEvaluateAlert:
assert result.new_state == AlertState.NOT_FIRING
assert inflight_alert_ids() == set()
- async def test_evaluate_firing_with_breaches(self, alert) -> None:
- with patch(
- "posthog.temporal.alerts.activities.check_alert_for_insight",
- return_value=AlertEvaluationResult(value=100.0, breaches=["value above threshold"]),
- ):
- env = ActivityEnvironment()
- result = await env.run(evaluate_alert, EvaluateAlertActivityInputs(alert_id=str(alert.id)))
+ @pytest.mark.parametrize("signal_error", [None, RuntimeError("signals unavailable")])
+ async def test_evaluate_firing_with_breaches(self, alert, signal_error: Exception | None) -> None:
+ # The inbox signal is best effort: a failure must not change the check or its notification.
+ reached_default_executor = False
+
+ async def _emit(**_kwargs) -> bool:
+ nonlocal reached_default_executor
+ # emit_signal runs sync work on the default executor. An evaluation thread that waits for
+ # the emission holds the only worker, so this would time out.
+ await asyncio.wait_for(sync_to_async(lambda: None, thread_sensitive=False)(), timeout=5)
+ reached_default_executor = True
+ if signal_error is not None:
+ raise signal_error
+ return True
+ emit = AsyncMock(side_effect=_emit)
+ loop = asyncio.get_running_loop()
+ loop.set_default_executor(ThreadPoolExecutor(max_workers=1))
+ try:
+ with (
+ patch(
+ "posthog.temporal.alerts.activities.check_alert_for_insight",
+ return_value=AlertEvaluationResult(value=100.0, breaches=["value above threshold"]),
+ ),
+ patch("posthog.temporal.alerts.alert_firing_signal.emit_signal", emit),
+ patch(
+ "posthog.temporal.alerts.alert_firing_signal.get_source_config",
+ return_value=SignalSourceConfigSnapshot(enabled=True, created_by_id=None, config={}),
+ ),
+ patch(
+ "posthog.temporal.alerts.alert_firing_signal.get_analytics_alert_scope",
+ return_value="all_firing_alerts",
+ ),
+ ):
+ env = ActivityEnvironment()
+ result = await env.run(evaluate_alert, EvaluateAlertActivityInputs(alert_id=str(alert.id)))
+ finally:
+ loop.set_default_executor(ThreadPoolExecutor())
+
+ assert reached_default_executor
+ emit.assert_awaited_once()
+ assert emit.await_args is not None
+ assert emit.await_args.kwargs["source_id"] == f"{alert.id}:{result.alert_check_id}"
assert result.new_state == AlertState.FIRING
assert result.should_notify is True
diff --git a/posthog/temporal/tests/test_alerts_alert_firing_signal.py b/posthog/temporal/tests/test_alerts_alert_firing_signal.py
new file mode 100644
index 000000000000..65be9e5ccd04
--- /dev/null
+++ b/posthog/temporal/tests/test_alerts_alert_firing_signal.py
@@ -0,0 +1,153 @@
+from posthog.test.base import BaseTest
+from unittest.mock import AsyncMock, patch
+
+from asgiref.sync import async_to_sync
+from parameterized import parameterized
+
+from posthog.schema import AlertState
+
+from posthog.redis import TEST_clear_clients
+from posthog.temporal.alerts.alert_firing_signal import dispatch_alert_firing_signal, prepare_alert_firing_signal
+from posthog.token_bucket import Budget, TEST_reset_scripts
+
+from products.alerts.backend.models.alert import AlertCheck, AlertConfiguration
+from products.product_analytics.backend.facade.models import Insight
+from products.signals.backend.facade.api import validate_signal_input
+from products.signals.backend.facade.source_configs import SignalSourceConfigSnapshot
+
+_MODULE = "posthog.temporal.alerts.alert_firing_signal"
+
+
+def _source(enabled: bool) -> SignalSourceConfigSnapshot:
+ return SignalSourceConfigSnapshot(enabled=enabled, created_by_id=None, config={})
+
+
+async def _validated_emit(**kwargs) -> bool:
+ validate_signal_input(
+ source_product=kwargs["source_product"],
+ source_type=kwargs["source_type"],
+ source_id=kwargs["source_id"],
+ description=kwargs["description"],
+ weight=kwargs["weight"],
+ extra=kwargs["extra"],
+ remediation=None,
+ )
+ return True
+
+
+class TestEmitAlertFiringSignal(BaseTest):
+ def setUp(self) -> None:
+ super().setUp()
+ TEST_clear_clients()
+ TEST_reset_scripts()
+ self.addCleanup(TEST_clear_clients)
+ self.addCleanup(TEST_reset_scripts)
+ self.insight = Insight.objects.create(team=self.team, name="Daily signups", query={})
+
+ def _alert_and_check(
+ self,
+ *,
+ investigation_agent_enabled: bool = False,
+ detector_config: dict | None = None,
+ earlier_states: list[AlertState] | None = None,
+ ) -> tuple[AlertConfiguration, AlertCheck]:
+ alert = AlertConfiguration.objects.create(
+ team=self.team,
+ insight=self.insight,
+ name="Signups dropped",
+ state=AlertState.FIRING,
+ investigation_agent_enabled=investigation_agent_enabled,
+ detector_config=detector_config,
+ created_by=self.user,
+ )
+ for state in earlier_states or []:
+ AlertCheck.objects.create(alert_configuration=alert, state=state, calculated_value=1.0)
+ check = AlertCheck.objects.create(alert_configuration=alert, state=AlertState.FIRING, calculated_value=1.0)
+ return alert, check
+
+ def _emit(
+ self,
+ alert: AlertConfiguration,
+ check: AlertCheck,
+ *,
+ previous_state: str = AlertState.NOT_FIRING,
+ scope: str = "all_firing_alerts",
+ source_enabled: bool | None = True,
+ emit: AsyncMock | None = None,
+ ) -> tuple[bool, AsyncMock]:
+ emit = emit or AsyncMock(side_effect=_validated_emit)
+ with (
+ patch(f"{_MODULE}.emit_signal", emit),
+ patch(
+ f"{_MODULE}.get_source_config",
+ return_value=None if source_enabled is None else _source(source_enabled),
+ ),
+ patch(f"{_MODULE}.get_analytics_alert_scope", return_value=scope),
+ ):
+ signal = prepare_alert_firing_signal(
+ alert, check, previous_state=previous_state, breaches=["The value is above the threshold"]
+ )
+ emitted = signal is not None and async_to_sync(dispatch_alert_firing_signal)(signal)
+ return emitted, emit
+
+ @parameterized.expand(
+ [
+ ("new_episode_without_agent", {}, {}, True),
+ ("threshold_alert_with_agent_flag_is_never_investigated", {"investigation_agent_enabled": True}, {}, True),
+ (
+ "investigated_alert_keeps_the_verdict_gate",
+ {"investigation_agent_enabled": True, "detector_config": {"type": "zscore"}},
+ {},
+ False,
+ ),
+ ("still_firing_is_the_same_episode", {}, {"previous_state": AlertState.FIRING}, False),
+ (
+ "error_during_an_episode_is_the_same_episode",
+ {"earlier_states": [AlertState.FIRING, AlertState.ERRORED, AlertState.ERRORED]},
+ {"previous_state": AlertState.ERRORED},
+ False,
+ ),
+ (
+ "error_before_the_first_fire_starts_an_episode",
+ {"earlier_states": [AlertState.NOT_FIRING, AlertState.ERRORED]},
+ {"previous_state": AlertState.ERRORED},
+ True,
+ ),
+ ("default_scope", {}, {"scope": "investigated_only"}, False),
+ ("source_disabled", {}, {"source_enabled": False}, False),
+ ("no_source_row", {}, {"source_enabled": None}, False),
+ ]
+ )
+ def test_emits_once_per_episode_only_when_every_gate_passes(
+ self, _name: str, alert_kwargs: dict, emit_kwargs: dict, expected: bool
+ ) -> None:
+ alert, check = self._alert_and_check(**alert_kwargs)
+
+ emitted, emit = self._emit(alert, check, **emit_kwargs)
+
+ assert emitted is expected
+ if expected:
+ emit.assert_awaited_once()
+ assert emit.await_args is not None
+ kwargs = emit.await_args.kwargs
+ assert (kwargs["source_product"], kwargs["source_type"]) == ("analytics", "alert_firing")
+ assert kwargs["source_id"] == kwargs["idempotency_key"] == f"{alert.id}:{check.id}"
+ else:
+ emit.assert_not_awaited()
+
+ @parameterized.expand(
+ [
+ ("dispatched_spends_the_cap", {"return_value": True}, False),
+ ("not_dispatched_refunds_it", {"return_value": False}, True),
+ ("emission_error_is_swallowed_and_refunds_it", {"side_effect": RuntimeError("temporal down")}, True),
+ ]
+ )
+ def test_cap_counts_only_dispatched_signals(self, _name: str, first_emit: dict, second_expected: bool) -> None:
+ first = self._alert_and_check()
+ second = self._alert_and_check()
+
+ with patch(f"{_MODULE}.CAP_BUDGET", Budget(burst=1, per_hour=1)):
+ self._emit(*first, emit=AsyncMock(**first_emit))
+ emitted, _ = self._emit(*second)
+
+ assert emitted is second_expected
diff --git a/products/signals/ARCHITECTURE.md b/products/signals/ARCHITECTURE.md
index 7bee4543b74f..63638039d30b 100644
--- a/products/signals/ARCHITECTURE.md
+++ b/products/signals/ARCHITECTURE.md
@@ -677,7 +677,9 @@ Per-team configuration for which signal sources are enabled.
- The Linear issue source reads `config.linear_team_ids` (list of Linear team id strings, capped at `SCOPE_IDS_MAX_COUNT`): the warehouse still syncs the whole workspace, but the emission fetcher adds an `IN` clause on the issue's team id, so only issues from those teams become signals. An absent, empty, or malformed list means every team, which keeps rows written before the key existed working and stops a bad row from silently narrowing the scope. Applies from the next sync; reports already in the inbox are not touched. The fetcher-side mechanism is generic (`scope_field` / `scope_config_key` on `SignalSourceTableConfig`), Linear is the only source that declares it. The key itself is declared in `contracts.SCOPE_CONFIG_KEYS`, so the API validates the same key the fetcher filters on.
- The product analytics source (`analytics` / `anomaly_investigation`) accepts `config.alert_scope`: `investigated_only` (the default when the key is absent) or `all_firing_alerts`. The serializer rejects any other value, and rejects the key on every other source (`contracts.ALERT_SCOPE_SOURCE`).
Other products read the scope through `facade.source_configs.get_analytics_alert_scope(team_id=...)`, never the row. The read returns `investigated_only` unless the stored value is `all_firing_alerts` and the `signals-analytics-all-alerts` flag is on for the team's organization. The flag check fails closed.
- The read does not check `enabled`: the emitter still gates on `is_source_enabled`. No emitter reads the scope yet.
+ The read does not check `enabled`: the emitter still gates on `is_source_enabled`.
+ With `all_firing_alerts`, insight alert evaluation (`posthog/temporal/alerts/alert_firing_signal.py`) emits `analytics` / `alert_firing` when an alert that the investigation agent does not investigate starts a firing episode. It emits once per episode (source id and idempotency key `<alert id>:<first check id>`), and a failure never changes the check. The evaluation thread runs the gates after the check is committed. The activity awaits the emission on its event loop once that thread returns, because `emit_signal` needs the default executor that the thread runs on. A per-team token bucket caps it, and an unavailable bucket skips the signal. Each skip after a read logs `alert_firing.signal_skipped` with a reason. Alerts the agent investigates keep the verdict gate in both scopes.
+ `alert_firing` has no config row of its own: `is_source_enabled` checks the `anomaly_investigation` row for it, so the one product analytics toggle turns both off.
- The serializer exposes a computed `status` field:
- data-import-backed sources (`github`, `linear`, `zendesk`) derive status from `ExternalDataSchema`
- The `signals_scout` source variant pairs with `source_type=cross_source_issue` and is the emission channel used by the headless Signals agent's `emit_signal_*` tools. It is the only `(source_product, source_type)` pair the agent emits today.
diff --git a/products/signals/backend/contracts.py b/products/signals/backend/contracts.py
index 0d8b4840677c..fb7ffdea0971 100644
--- a/products/signals/backend/contracts.py
+++ b/products/signals/backend/contracts.py
@@ -506,6 +506,30 @@ class AnalyticsAnomalyInvestigationSignalInput(SignalInputBase):
extra: AnalyticsAnomalyInvestigationSignalExtra
+# An insight alert that started to fire and that the investigation agent does not investigate. Kept
+# apart from the investigation payload, which requires a verdict this path never has.
+class AnalyticsAlertFiringSignalExtra(SignalExtraBase):
+ alert_id: str
+ alert_name: str
+ insight_id: str
+ # The check that started the firing episode. It is also the signal's source id.
+ alert_check_id: str
+ # `threshold`, or the anomaly detector type.
+ detector_type: str
+ breaches: list[str]
+ episode_started_at: str
+ url: str
+ insight_name: str | None = None
+ insight_short_id: str | None = None
+ triggered_dates: list[str] | None = None
+
+
+class AnalyticsAlertFiringSignalInput(SignalInputBase):
+ source_type: Literal[SignalSourceType.ALERT_FIRING]
+ source_product: Literal[SignalSourceProduct.ANALYTICS]
+ extra: AnalyticsAlertFiringSignalExtra
+
+
# ── Health checks ───────────────────────────────────────────────────────────────
HealthCheckSeverity = Literal["critical", "warning", "info"]
@@ -1961,6 +1985,7 @@ SignalInput = Annotated[
| MonitoringUnresolvedSignalInput
| LogsAlertStateChangeSignalInput
| AnalyticsAnomalyInvestigationSignalInput
+ | AnalyticsAlertFiringSignalInput
| HealthCheckSignalInput
| ReplayVisionScannerFindingSignalInput
| FreshdeskTicketSignalInput
@@ -2077,6 +2102,7 @@ SIGNAL_INPUT_VARIANTS: tuple[type[SignalInputBase], ...] = (
SignalsScoutSignalInput,
LogsAlertStateChangeSignalInput,
AnalyticsAnomalyInvestigationSignalInput,
+ AnalyticsAlertFiringSignalInput,
HealthCheckSignalInput,
ReplayVisionScannerFindingSignalInput,
FreshdeskTicketSignalInput,
diff --git a/products/signals/backend/enums.py b/products/signals/backend/enums.py
index 80020c346b47..0aa6c0244a03 100644
--- a/products/signals/backend/enums.py
+++ b/products/signals/backend/enums.py
@@ -243,6 +243,7 @@ class SignalSourceType(StrEnum):
HEALTH_ISSUE = "health_issue"
SCANNER_FINDING = "scanner_finding"
ANOMALY_INVESTIGATION = "anomaly_investigation"
+ ALERT_FIRING = "alert_firing"
FEEDBACK = "feedback"
REVIEW = "review"
CI_FLAKY_CHECK = "ci_flaky_check"
diff --git a/products/signals/backend/facade/signal_extras.py b/products/signals/backend/facade/signal_extras.py
index 62aa5065876e..8ceb52d683ed 100644
--- a/products/signals/backend/facade/signal_extras.py
+++ b/products/signals/backend/facade/signal_extras.py
@@ -1,6 +1,7 @@
"""Per-source `extra` payload contracts that an emitting product builds for `emit_signal`."""
from products.signals.backend.contracts import (
+ AnalyticsAlertFiringSignalExtra as AnalyticsAlertFiringSignalExtra,
EngineeringAnalyticsCIBrokenDefaultBranchSignalExtra as EngineeringAnalyticsCIBrokenDefaultBranchSignalExtra,
EngineeringAnalyticsCIDurationRegressionSignalExtra as EngineeringAnalyticsCIDurationRegressionSignalExtra,
EngineeringAnalyticsCIFlakyCheckSignalExtra as EngineeringAnalyticsCIFlakyCheckSignalExtra,
diff --git a/products/signals/backend/models.py b/products/signals/backend/models.py
index 7153d48c6b15..67fffcc9171e 100644
--- a/products/signals/backend/models.py
+++ b/products/signals/backend/models.py
@@ -99,7 +99,7 @@ class SignalSourceConfig(UUIDModel):
SourceProduct = SignalSourceProduct
# Source-type choices are intentionally a *subset* of the full SignalSourceType taxonomy: only the
- # types that carry a per-team config row live here. session_problem gates through another config.
+ # types that carry a per-team config row live here. session_problem and alert_firing gate through another config.
# evaluation is retired, and stays in the taxonomy only so old signals still resolve to a label.
# Every source_type the emission registry emits must appear here, or enabling that source 400s.
class SourceType(models.TextChoices):
@@ -170,6 +170,10 @@ class SignalSourceConfig(UUIDModel):
if source_product == cls.SourceProduct.SESSION_REPLAY and source_type == "session_problem":
source_type = cls.SourceType.SESSION_ANALYSIS_CLUSTER
+ # Firing alerts are a scope of the product analytics source, so they share its row and toggle.
+ if source_product == cls.SourceProduct.ANALYTICS and source_type == SignalSourceType.ALERT_FIRING:
+ source_type = cls.SourceType.ANOMALY_INVESTIGATION
+
return cls.objects.filter(
team_id=team_id,
source_product=source_product,
diff --git a/products/signals/backend/test/test_signal_source_config_api.py b/products/signals/backend/test/test_signal_source_config_api.py
index 8bc85324d1c1..0f5107c49841 100644
--- a/products/signals/backend/test/test_signal_source_config_api.py
+++ b/products/signals/backend/test/test_signal_source_config_api.py
@@ -746,6 +746,18 @@ class TestIsSourceEnabledGating(APIBaseTest):
assert SignalSourceConfig.is_source_enabled(self.team.id, "session_replay", "session_problem") is True
+ @parameterized.expand([("no_row", None, False), ("enabled_row", True, True), ("disabled_row", False, False)])
+ def test_alert_firing_gated_by_product_analytics_row(self, _name, existing_enabled, expected):
+ if existing_enabled is not None:
+ SignalSourceConfig.objects.create(
+ team=self.team,
+ source_product=SignalSourceConfig.SourceProduct.ANALYTICS,
+ source_type=SignalSourceConfig.SourceType.ANOMALY_INVESTIGATION,
+ enabled=existing_enabled,
+ )
+
+ assert SignalSourceConfig.is_source_enabled(self.team.id, "analytics", "alert_firing") is expected
+
def test_pganalyze_issue_requires_own_config(self):
SignalSourceConfig.objects.create(
team=self.team,
diff --git a/products/signals/frontend/generated/api.schemas.ts b/products/signals/frontend/generated/api.schemas.ts
index e8a10296931c..09489809cd0d 100644
--- a/products/signals/frontend/generated/api.schemas.ts
+++ b/products/signals/frontend/generated/api.schemas.ts
@@ -3831,6 +3831,7 @@ export const SignalSourceProductApi = {
* * `health_issue` - health_issue
* * `scanner_finding` - scanner_finding
* * `anomaly_investigation` - anomaly_investigation
+ * * `alert_firing` - alert_firing
* * `feedback` - feedback
* * `review` - review
* * `ci_flaky_check` - ci_flaky_check
@@ -3860,6 +3861,7 @@ export const SignalSourceTypeApi = {
HealthIssue: 'health_issue',
ScannerFinding: 'scanner_finding',
AnomalyInvestigation: 'anomaly_investigation',
+ AlertFiring: 'alert_firing',
Feedback: 'feedback',
Review: 'review',
CiFlakyCheck: 'ci_flaky_check',
@@ -4161,6 +4163,20 @@ export interface AnalyticsAnomalyInvestigationSignalExtraApi {
evaluation_key?: string | null
}
+export interface AnalyticsAlertFiringSignalExtraApi {
+ alert_id: string
+ alert_name: string
+ insight_id: string
+ alert_check_id: string
+ detector_type: string
+ breaches: string[]
+ episode_started_at: string
+ url: string
+ insight_name?: string | null
+ insight_short_id?: string | null
+ triggered_dates?: string[] | null
+}
+
export type HealthCheckSignalExtraSeverityEnumApi =
(typeof HealthCheckSignalExtraSeverityEnumApi)[keyof typeof HealthCheckSignalExtraSeverityEnumApi]
@@ -4974,6 +4990,7 @@ export type SignalExtraApi =
| LogsAlertStateChangeSignalExtraApi
| ReplayVisionScannerFindingSignalExtraApi
| AnalyticsAnomalyInvestigationSignalExtraApi
+ | AnalyticsAlertFiringSignalExtraApi
| HealthCheckSignalExtraApi
| EngineeringAnalyticsCIFlakyCheckSignalExtraApi
| EngineeringAnalyticsCIBrokenDefaultBranchSignalExtraApi
@@ -5248,6 +5265,7 @@ export interface SignalNodeApi {
* * `health_issue` - health_issue
* * `scanner_finding` - scanner_finding
* * `anomaly_investigation` - anomaly_investigation
+ * * `alert_firing` - alert_firing
* * `feedback` - feedback
* * `review` - review
* * `ci_flaky_check` - ci_flaky_check
diff --git a/services/mcp/src/api/generated.ts b/services/mcp/src/api/generated.ts
index 6bf3282bca58..af739595a16e 100644
--- a/services/mcp/src/api/generated.ts
+++ b/services/mcp/src/api/generated.ts
@@ -13764,6 +13764,20 @@ export namespace Schemas {
Evaluation: 'evaluation',
} as const;
+ export interface AnalyticsAlertFiringSignalExtra {
+ alert_id: string;
+ alert_name: string;
+ insight_id: string;
+ alert_check_id: string;
+ detector_type: string;
+ breaches: string[];
+ episode_started_at: string;
+ url: string;
+ insight_name?: string | null;
+ insight_short_id?: string | null;
+ triggered_dates?: string[] | null;
+ }
+
export interface AnalyticsAnomalyInvestigationSignalExtra {
alert_id: string;
alert_name: string;
@@ -98102,6 +98116,7 @@ export namespace Schemas {
* * `health_issue` - health_issue
* * `scanner_finding` - scanner_finding
* * `anomaly_investigation` - anomaly_investigation
+ * * `alert_firing` - alert_firing
* * `feedback` - feedback
* * `review` - review
* * `ci_flaky_check` - ci_flaky_check
@@ -98132,6 +98147,7 @@ export namespace Schemas {
HealthIssue: 'health_issue',
ScannerFinding: 'scanner_finding',
AnomalyInvestigation: 'anomaly_investigation',
+ AlertFiring: 'alert_firing',
Feedback: 'feedback',
Review: 'review',
CiFlakyCheck: 'ci_flaky_check',
@@ -98411,7 +98427,7 @@ export namespace Schemas {
created_at: string | null;
}
- export type SignalExtra = SessionProblemSignalExtra | LlmEvalSignalExtra | LlmEvalReportSignalExtra | ZendeskTicketSignalExtra | GithubIssueSignalExtra | LinearIssueSignalExtra | JiraIssueSignalExtra | ConversationsTicketSignalExtra | ErrorTrackingSignalExtra | PgAnalyzeIssueSignalExtra | EndpointExecutionFailedSignalExtra | EndpointBreakdownLimitExceededSignalExtra | SignalsScoutSignalExtra | CheckFailedSignalExtra | MonitoringUnresolvedSignalExtra | LogsAlertStateChangeSignalExtra | ReplayVisionScannerFindingSignalExtra | AnalyticsAnomalyInvestigationSignalExtra | HealthCheckSignalExtra | EngineeringAnalyticsCIFlakyCheckSignalExtra | EngineeringAnalyticsCIBrokenDefaultBranchSignalExtra | EngineeringAnalyticsCIDurationRegressionSignalExtra | FreshdeskTicketSignalExtra | FreshserviceTicketSignalExtra | FrontConversationSignalExtra | GorgiasTicketSignalExtra | KustomerConversationSignalExtra | DixaConversationSignalExtra | PlainThreadSignalExtra | GitlabIssueSignalExtra | GiteaIssueSignalExtra | ShortcutStorySignalExtra | ClickupTaskSignalExtra | WrikeTaskSignalExtra | TrelloCardSignalExtra | BugherdTaskSignalExtra | SentryIssueSignalExtra | RollbarItemSignalExtra | BugsnagErrorSignalExtra | HoneybadgerFaultSignalExtra | RaygunErrorGroupSignalExtra | DatadogSignalExtra | SnykScannerFindingSignalExtra | SonarqubeScannerFindingSignalExtra | SemgrepScannerFindingSignalExtra | Rapid7InsightvmScannerFindingSignalExtra | FeaturebaseFeedbackSignalExtra | FrillFeedbackSignalExtra | AhaFeedbackSignalExtra | UservoiceFeedbackSignalExtra | ProductboardFeedbackSignalExtra | CannyFeedbackSignalExtra | AsknicelyFeedbackSignalExtra | RetentlyFeedbackSignalExtra | UsersnapFeedbackSignalExtra | TypeformFeedbackSignalExtra | QualtricsFeedbackSignalExtra | SurveymonkeyFeedbackSignalExtra | FormbricksFeedbackSignalExtra | SurvicateFeedbackSignalExtra | SurveysparrowFeedbackSignalExtra | AppfiguresReviewSignalExtra | AppfollowReviewSignalExtra | JudgemeReviewsReviewSignalExtra | IntercomTicketSignalExtra | HubspotTicketSignalExtra | Dynamics365TicketSignalExtra | ZohoCrmTicketSignalExtra | GoogleSearchConsoleSearchOpportunitySignalExtra | HelpscoutConversationSignalExtra | DecagonConversationSignalExtra | VitallyConversationSignalExtra | PagerdutyIncidentSignalExtra | OpsgenieAlertSignalExtra | IncidentIoIncidentSignalExtra | FirehydrantIncidentSignalExtra | SquadcastIncidentSignalExtra | ServicenowIncidentSignalExtra | SolarwindsServiceDeskIncidentSignalExtra | GrafanaIrmIncidentSignalExtra | XmattersIncidentSignalExtra | LaceworkScannerFindingSignalExtra | OrcaSecurityScannerFindingSignalExtra | TenableVulnerabilityManagementScannerFindingSignalExtra | BetterstackIncidentSignalExtra | AsanaIssueSignalExtra | MondayIssueSignalExtra | PlaneIssueSignalExtra | AzureDevopsIssueSignalExtra | MonteCarloAlertSignalExtra | BigeyeIssueSignalExtra | DynatraceIncidentSignalExtra | StatuspageIncidentSignalExtra | CronitorIncidentSignalExtra | InstatusIncidentSignalExtra | GooglePlayConsoleIssueSignalExtra | AzureApplicationInsightsIssueSignalExtra | AppsignalIssueSignalExtra | CursorIssueSignalExtra | TriggerDevErrorSignalExtra | ChecklyErrorGroupSignalExtra | RoarkIssueSignalExtra | SleekplanFeedbackSignalExtra | BettermodeFeedbackSignalExtra | DiscourseFeedbackSignalExtra | MintlifyFeedbackSignalExtra | LangsmithFeedbackSignalExtra | SprigFeedbackSignalExtra | GainsightPxFeedbackSignalExtra | TrustpilotReviewSignalExtra | OkendoReviewSignalExtra | AwsSecurityHubScannerFindingSignalExtra | AwsGuarddutyScannerFindingSignalExtra | AwsInspectorScannerFindingSignalExtra | MicrosoftDefenderCloudAppsScannerFindingSignalExtra;
+ export type SignalExtra = SessionProblemSignalExtra | LlmEvalSignalExtra | LlmEvalReportSignalExtra | ZendeskTicketSignalExtra | GithubIssueSignalExtra | LinearIssueSignalExtra | JiraIssueSignalExtra | ConversationsTicketSignalExtra | ErrorTrackingSignalExtra | PgAnalyzeIssueSignalExtra | EndpointExecutionFailedSignalExtra | EndpointBreakdownLimitExceededSignalExtra | SignalsScoutSignalExtra | CheckFailedSignalExtra | MonitoringUnresolvedSignalExtra | LogsAlertStateChangeSignalExtra | ReplayVisionScannerFindingSignalExtra | AnalyticsAnomalyInvestigationSignalExtra | AnalyticsAlertFiringSignalExtra | HealthCheckSignalExtra | EngineeringAnalyticsCIFlakyCheckSignalExtra | EngineeringAnalyticsCIBrokenDefaultBranchSignalExtra | EngineeringAnalyticsCIDurationRegressionSignalExtra | FreshdeskTicketSignalExtra | FreshserviceTicketSignalExtra | FrontConversationSignalExtra | GorgiasTicketSignalExtra | KustomerConversationSignalExtra | DixaConversationSignalExtra | PlainThreadSignalExtra | GitlabIssueSignalExtra | GiteaIssueSignalExtra | ShortcutStorySignalExtra | ClickupTaskSignalExtra | WrikeTaskSignalExtra | TrelloCardSignalExtra | BugherdTaskSignalExtra | SentryIssueSignalExtra | RollbarItemSignalExtra | BugsnagErrorSignalExtra | HoneybadgerFaultSignalExtra | RaygunErrorGroupSignalExtra | DatadogSignalExtra | SnykScannerFindingSignalExtra | SonarqubeScannerFindingSignalExtra | SemgrepScannerFindingSignalExtra | Rapid7InsightvmScannerFindingSignalExtra | FeaturebaseFeedbackSignalExtra | FrillFeedbackSignalExtra | AhaFeedbackSignalExtra | UservoiceFeedbackSignalExtra | ProductboardFeedbackSignalExtra | CannyFeedbackSignalExtra | AsknicelyFeedbackSignalExtra | RetentlyFeedbackSignalExtra | UsersnapFeedbackSignalExtra | TypeformFeedbackSignalExtra | QualtricsFeedbackSignalExtra | SurveymonkeyFeedbackSignalExtra | FormbricksFeedbackSignalExtra | SurvicateFeedbackSignalExtra | SurveysparrowFeedbackSignalExtra | AppfiguresReviewSignalExtra | AppfollowReviewSignalExtra | JudgemeReviewsReviewSignalExtra | IntercomTicketSignalExtra | HubspotTicketSignalExtra | Dynamics365TicketSignalExtra | ZohoCrmTicketSignalExtra | GoogleSearchConsoleSearchOpportunitySignalExtra | HelpscoutConversationSignalExtra | DecagonConversationSignalExtra | VitallyConversationSignalExtra | PagerdutyIncidentSignalExtra | OpsgenieAlertSignalExtra | IncidentIoIncidentSignalExtra | FirehydrantIncidentSignalExtra | SquadcastIncidentSignalExtra | ServicenowIncidentSignalExtra | SolarwindsServiceDeskIncidentSignalExtra | GrafanaIrmIncidentSignalExtra | XmattersIncidentSignalExtra | LaceworkScannerFindingSignalExtra | OrcaSecurityScannerFindingSignalExtra | TenableVulnerabilityManagementScannerFindingSignalExtra | BetterstackIncidentSignalExtra | AsanaIssueSignalExtra | MondayIssueSignalExtra | PlaneIssueSignalExtra | AzureDevopsIssueSignalExtra | MonteCarloAlertSignalExtra | BigeyeIssueSignalExtra | DynatraceIncidentSignalExtra | StatuspageIncidentSignalExtra | CronitorIncidentSignalExtra | InstatusIncidentSignalExtra | GooglePlayConsoleIssueSignalExtra | AzureApplicationInsightsIssueSignalExtra | AppsignalIssueSignalExtra | CursorIssueSignalExtra | TriggerDevErrorSignalExtra | ChecklyErrorGroupSignalExtra | RoarkIssueSignalExtra | SleekplanFeedbackSignalExtra | BettermodeFeedbackSignalExtra | DiscourseFeedbackSignalExtra | MintlifyFeedbackSignalExtra | LangsmithFeedbackSignalExtra | SprigFeedbackSignalExtra | GainsightPxFeedbackSignalExtra | TrustpilotReviewSignalExtra | OkendoReviewSignalExtra | AwsSecurityHubScannerFindingSignalExtra | AwsGuarddutyScannerFindingSignalExtra | AwsInspectorScannerFindingSignalExtra | MicrosoftDefenderCloudAppsScannerFindingSignalExtra;
export type SignalMatchMetadata = MatchedMetadata | NoMatchMetadata;
@@ -98560,6 +98576,7 @@ export namespace Schemas {
* * `health_issue` - health_issue
* * `scanner_finding` - scanner_finding
* * `anomaly_investigation` - anomaly_investigation
+ * * `alert_firing` - alert_firing
* * `feedback` - feedback
* * `review` - review
* * `ci_flaky_check` - ci_flaky_check