@odigos/ui-kit 0.0.304 → 0.0.306

package/lib/containers/insights/recommendations/helpers.d.ts

@@ -0,0 +1,200 @@
+import type { DefaultTheme } from 'styled-components';
+import type { HoverAction } from '../../../components/hover-actions';
+import { InsightsRecommendationConfidenceLevel, StatusType, type InsightsCorrelationSelector, type InsightsCorrelationSpec, type InsightsRecommendation, type InsightsRecommendationRule, type InsightsTransactionKind } from '../../../types';
+import { type NoDataProps, type TableColumn, type TableRow } from '../../../components';
+export declare enum RecommendationsFilterMode {
+    Open = "open",
+    Applied = "applied",
+    Dismissed = "dismissed"
+}
+export declare enum RecommendationsColumnKeys {
+    Confidence = "confidence",
+    Recommendation = "recommendation",
+    /**
+     * What the row covers. Named for the guardrail scope it would extend, not for
+     * a transaction: only `attribute_correlation` has one, and a column headed
+     * "Transaction" holding the word "Service-wide" contradicts its own header.
+     */
+    Scope = "scope",
+    Evidence = "evidence",
+    Tags = "tags"
+}
+export declare const RECOMMENDATIONS_TABLE_COLUMNS: TableColumn[];
+export interface RecommendationCounts {
+    total: number;
+    open: number;
+    applied: number;
+    dismissed: number;
+    highConfidence: number;
+}
+export declare const getRecommendationCounts: (items: InsightsRecommendation[]) => RecommendationCounts;
+export declare const filterRecommendationsByState: (items: InsightsRecommendation[], filter: RecommendationsFilterMode) => InsightsRecommendation[];
+/**
+ * Runs on first render for every row, so it must survive both kinds. `spec` and
+ * `operation` belong to `attribute_correlation` and are simply absent on a
+ * service card; `rules` is the other way round, and its labels and items are
+ * what someone searching for "stripe" or "ledger-service" is actually after.
+ */
+export declare const searchRecommendations: (items: InsightsRecommendation[], search: string) => InsightsRecommendation[];
+export declare const isServiceGuardrail: (recommendation: InsightsRecommendation) => boolean;
+export declare const sortRecommendations: (items: InsightsRecommendation[]) => InsightsRecommendation[];
+export declare const CONFIDENCE_STATUS: Record<InsightsRecommendationConfidenceLevel, StatusType>;
+/** "service · span · attr" plus the extract regex when the rule narrows the value. */
+export declare const formatSelector: (selector: InsightsCorrelationSelector) => string;
+/** "<namespace>/<service>", the service every row is scoped under. */
+export declare const formatRecommendationScope: (recommendation: InsightsRecommendation) => string;
+/**
+ * What inside that service the row covers: every operation for a service
+ * guardrail, one transaction's operation for a correlation. A correlation with
+ * no `operation` falls back to its transaction id rather than borrowing the
+ * guardrail's "Service-wide", which would be a lie about its blast radius.
+ */
+export declare const formatRecommendationScopeDetail: (recommendation: InsightsRecommendation) => string;
+/**
+ * `liveSince` / `liveLast` are documented as omitted until the first live check,
+ * but the server declares them as Go `time.Time` with `omitempty` — which is a
+ * no-op on structs — so it emits the Go zero value `"0001-01-01T00:00:00Z"`
+ * instead. Four fields carry the bug: the two on the confidence block and the
+ * two on every rule. Every read of them goes through here rather than trusting
+ * the field's presence.
+ *
+ * A ClickHouse left-join miss would surface as the epoch instead, which the
+ * repo layer already guards, but both sentinels are rejected here anyway.
+ */
+export declare const isLiveTimestamp: (value?: string | null) => value is string;
+/** The timestamp if it is real, `null` for absent, blank, the Go zero time or the epoch. */
+export declare const liveTimestamp: (value?: string | null) => string | null;
+/**
+ * Catalog order — the order the engine emits `rules[]` in and the order the UI
+ * renders them. Rules the service already enforces (or switched off) are left
+ * out by the engine, so a card commonly carries fewer than four.
+ */
+export declare const RECOMMENDATION_RULE_ORDER: string[];
+/**
+ * The server sends `label` and `description` on every rule, so these are only a
+ * fallback for a rule that arrives without them. `rule` is an open string on
+ * the wire, so an unknown key falls back to itself rather than rendering blank.
+ */
+export declare const RULE_KEY_LABEL: Record<string, string>;
+export declare const RULE_KEY_DESCRIPTION: Record<string, string>;
+export declare const getRuleLabel: (rule: InsightsRecommendationRule) => string;
+export declare const getRuleDescription: (rule: InsightsRecommendationRule) => string;
+/** Defensive: the engine already emits catalog order, unknown keys keep their relative place at the end. */
+export declare const sortRecommendationRules: (rules: InsightsRecommendationRule[]) => InsightsRecommendationRule[];
+/**
+ * `allowed_transactions` items are `"<KIND>\toperation"` — a real TAB, matched
+ * exactly and case-sensitively at enforcement. Splitting on a space would be
+ * wrong: operations contain spaces ("GET /accounts"). Every other rule's items
+ * are plain strings and come back with no kind.
+ */
+export declare const splitRuleItem: (item: string) => {
+    kind?: string;
+    value: string;
+};
+/** One-line rendering of an item — the tab becomes a space, never a literal tab. */
+export declare const formatRuleItem: (item: string) => string;
+/**
+ * What live traffic has said about one rule while the card sat open. `liveChecked === 0`
+ * is the "never shadow-checked" case — the same state the zero timestamps mark.
+ */
+export declare const formatRuleLive: (rule: InsightsRecommendationRule) => {
+    text: string;
+    violated: boolean;
+};
+/** `${label} (${count})`-style coverage line, mirroring the server's own summary. */
+export declare const formatRuleCoverage: (rules: InsightsRecommendationRule[]) => string;
+/**
+ * The evidence summary for a row, per kind — the two kinds count different
+ * things under the same keys and must not borrow each other's wording.
+ *
+ * `attribute_correlation`: the stored-sample hit rate plus what live traffic
+ * has said since; a relation live traffic already broke is the one case where
+ * applying fires violations immediately, so it is called out.
+ *
+ * `service_guardrail`: `sampleCount` is promoted transactions, not samples, and
+ * the live counters sum **rule-checks** across up to four rules — one trace can
+ * contribute several — so they are never labelled "traces" here.
+ */
+export declare const formatEvidence: (recommendation: InsightsRecommendation) => {
+    samples: string;
+    live: string;
+    liveBroken: boolean;
+};
+export declare const getTableRowsForRecommendations: (theme: DefaultTheme, recommendations: InsightsRecommendation[], onRowClick?: (recommendation: InsightsRecommendation) => void, selected?: InsightsRecommendation[], toggleSelection?: (recommendation: InsightsRecommendation, isSelected: boolean) => void) => TableRow[];
+export interface RecommendationRowActionHandlers {
+    onApply: (recommendation: InsightsRecommendation) => void;
+    onEdit: (recommendation: InsightsRecommendation) => void;
+    onDismiss: (recommendation: InsightsRecommendation) => void;
+    onRestore: (recommendation: InsightsRecommendation) => void;
+    onRevert: (recommendation: InsightsRecommendation) => void;
+}
+/** Actions follow the row's state: an applied row can only be reverted, a dismissed one restored. */
+export declare const getRecommendationRowActions: (row: TableRow, recommendations: InsightsRecommendation[], handlers: RecommendationRowActionHandlers) => HoverAction[];
+/**
+ * The empty state does triple duty, and the error case matters most: an older
+ * odigos-insights build has no /api/v1/recommendations route and answers 404,
+ * which would otherwise read as "you simply have none". Surface the service's
+ * own message so the cause is visible rather than guessed at.
+ */
+export declare const getNoDataProps: ({ error, search, hasAny }: {
+    error?: Error;
+    search: string;
+    hasAny: boolean;
+}) => NoDataProps;
+/** How many rules of one transaction render before the rest fold away. */
+export declare const RULES_SHOWN_PER_TRANSACTION = 5;
+export interface RecommendationTxnGroup {
+    transactionId: string;
+    operation: string;
+    /** Absent only if a correlation ever arrives without its transaction kind. */
+    kind?: InsightsTransactionKind | null;
+    items: InsightsRecommendation[];
+    highCount: number;
+}
+export interface RecommendationServiceCard {
+    key: string;
+    namespace: string;
+    service: string;
+    /**
+     * The service's own `service_guardrail` recommendation, rendered above the
+     * transaction groups. At most one per service per lifecycle state — the id is
+     * derived from `namespace/service`, so a service can never have two.
+     */
+    guardrail?: InsightsRecommendation;
+    transactions: RecommendationTxnGroup[];
+    count: number;
+    highCount: number;
+}
+/**
+ * Mirrors buildRecommendationCards in the insights debug UI: services ordered
+ * by how much is waiting and how confident the engine is, transactions in the
+ * order they were seen, and rules by the engine's own rank.
+ */
+export declare const buildRecommendationCards: (items: InsightsRecommendation[]) => RecommendationServiceCard[];
+export declare enum RuleColumnKeys {
+    Rule = "rule",
+    Confidence = "confidence",
+    Tags = "tags"
+}
+/** Columns for the rules inside a transaction — no service/transaction column, the group says it. */
+export declare const RULE_TABLE_COLUMNS: TableColumn[];
+export declare const getTableRowsForRules: (theme: DefaultTheme, recommendations: InsightsRecommendation[], onRowClick: (recommendation: InsightsRecommendation) => void, selected: InsightsRecommendation[], toggleSelection: (recommendation: InsightsRecommendation, isSelected: boolean) => void) => TableRow[];
+/**
+ * The heading of the consequence block — what "broken" means for this relation.
+ * Correlation-only: a service guardrail has no spec, so callers pass `null` and
+ * get the allowlist wording instead.
+ */
+export declare const formatBreakCondition: (spec?: InsightsCorrelationSpec | null) => "If anything falls outside the lists" | "If they differ" | "If they match";
+/**
+ * What a violation would mean. Mirrors the two consequences `relationWhy` writes
+ * in the engine, rather than parsing them back out of the generated `spec.why`.
+ */
+export declare const formatConsequence: (recommendation: InsightsRecommendation) => string;
+export declare const CONFIDENCE_LABEL: Record<InsightsRecommendationConfidenceLevel, string>;
+/** `transform` is an open string on the wire, so unknown kinds fall back to themselves. */
+export declare const TRANSFORM_LABEL: Record<string, string>;
+export interface EvidenceLine {
+    text: string;
+    ok: boolean;
+}
+export declare const getEvidenceLines: (recommendation: InsightsRecommendation) => EvidenceLine[];

package/lib/containers/insights/recommendations/index.d.ts

@@ -0,0 +1,2 @@
+import { type FC } from 'react';
+export declare const Recommendations: FC;

package/lib/containers/insights/recommendations/rule-card.d.ts

@@ -0,0 +1,11 @@
+import { type FC } from 'react';
+import { type InsightsRecommendation } from '../../../types';
+export interface RuleCardProps {
+    recommendation: InsightsRecommendation;
+    onApply: (recommendation: InsightsRecommendation) => void;
+    onEdit: (recommendation: InsightsRecommendation) => void;
+    onDismiss: (recommendation: InsightsRecommendation) => void;
+    onRestore: (recommendation: InsightsRecommendation) => void;
+    onRevert: (recommendation: InsightsRecommendation) => void;
+}
+export declare const RuleCard: FC<RuleCardProps>;

package/lib/containers/instrumentation-agents/agents-table.d.ts

@@ -0,0 +1,8 @@
+import { type FC } from 'react';
+import type { InstrumentationAgent } from '../../types';
+export interface AgentsTableProps {
+    agents: InstrumentationAgent[];
+    isLoading: boolean;
+    onAgentClick?: (agent: InstrumentationAgent) => void;
+}
+export declare const AgentsTable: FC<AgentsTableProps>;

package/lib/containers/instrumentation-agents/helpers.d.ts

@@ -0,0 +1,4 @@
+import type { InstrumentationAgent } from '../../types';
+/** Sources holding at least one container of this language. */
+export declare const getAgentSourcesLabel: (sources: number) => string;
+export declare const filterAgentsBySearch: (agents: InstrumentationAgent[], search: string) => InstrumentationAgent[];

package/lib/containers/instrumentation-agents/index.d.ts

@@ -0,0 +1,4 @@
+import { type FC } from 'react';
+import type { InstrumentationAgentsProps } from './types';
+export * from './types';
+export declare const InstrumentationAgents: FC<InstrumentationAgentsProps>;

package/lib/containers/instrumentation-agents/types.d.ts

@@ -0,0 +1,3 @@
+export interface InstrumentationAgentsProps {
+    docsUrl?: string;
+}