@equipe-tech/observability 0.2.1 → 0.3.5

package/dist/contract/OrganizationEvents.d.ts

@@ -0,0 +1,165 @@
+export declare const organizationContractVersion = 1;
+export declare const organizationEvents: {
+    readonly RequestCompleted: {
+        readonly name: "request.completed";
+        readonly kind: "request";
+        readonly defaultSeverity: "info";
+        readonly mandatory: true;
+        readonly sampling: {
+            readonly kind: "always";
+        };
+        readonly attributes: {};
+    };
+    readonly DependencyCall: {
+        readonly name: "dependency.call";
+        readonly kind: "operation";
+        readonly defaultSeverity: "info";
+        readonly mandatory: false;
+        readonly sampling: {
+            readonly kind: "always";
+        };
+        readonly attributes: {
+            "dependency.name": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+            "dependency.operation": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+        };
+    };
+    readonly LlmCall: {
+        readonly name: "llm.call";
+        readonly kind: "operation";
+        readonly defaultSeverity: "info";
+        readonly mandatory: false;
+        readonly sampling: {
+            readonly kind: "always";
+        };
+        readonly attributes: {
+            "llm.provider": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+            "llm.model": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+            "llm.operation": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+        };
+    };
+    readonly SchedulerRun: {
+        readonly name: "scheduler.run";
+        readonly kind: "operation";
+        readonly defaultSeverity: "info";
+        readonly mandatory: true;
+        readonly sampling: {
+            readonly kind: "always";
+        };
+        readonly attributes: {
+            "scheduler.job": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+        };
+    };
+    readonly QueueJob: {
+        readonly name: "queue.job";
+        readonly kind: "operation";
+        readonly defaultSeverity: "info";
+        readonly mandatory: false;
+        readonly sampling: {
+            readonly kind: "always";
+        };
+        readonly attributes: {
+            "queue.name": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+            "queue.job": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+        };
+    };
+    readonly PaymentAttempt: {
+        readonly name: "payment.attempt";
+        readonly kind: "operation";
+        readonly defaultSeverity: "info";
+        readonly mandatory: true;
+        readonly sampling: {
+            readonly kind: "always";
+        };
+        readonly attributes: {
+            "payment.provider": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+            "payment.operation": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+        };
+    };
+    readonly UsageRecorded: {
+        readonly name: "usage.recorded";
+        readonly kind: "domain";
+        readonly defaultSeverity: "info";
+        readonly mandatory: false;
+        readonly sampling: {
+            readonly kind: "always";
+        };
+        readonly attributes: {
+            "usage.type": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+            "usage.unit": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+        };
+    };
+    readonly AuditRecorded: {
+        readonly name: "audit.recorded";
+        readonly kind: "audit";
+        readonly defaultSeverity: "info";
+        readonly mandatory: true;
+        readonly sampling: {
+            readonly kind: "always";
+        };
+        readonly attributes: {};
+    };
+    readonly BrowserError: {
+        readonly name: "browser.error";
+        readonly kind: "defect";
+        readonly defaultSeverity: "error";
+        readonly mandatory: true;
+        readonly sampling: {
+            readonly kind: "always";
+        };
+        readonly attributes: {
+            "error.origin": {
+                classification: "public";
+                required: true;
+                metricLabel: true;
+            };
+        };
+    };
+};

package/dist/contract/OrganizationEvents.js

@@ -0,0 +1,97 @@
+import { defineEventDefinitions } from "./TelemetryContract.js";
+const publicRequired = {
+    classification: "public",
+    required: true,
+    metricLabel: true,
+};
+export const organizationContractVersion = 1;
+export const organizationEvents = defineEventDefinitions({
+    RequestCompleted: {
+        name: "request.completed",
+        kind: "request",
+        defaultSeverity: "info",
+        mandatory: true,
+        sampling: { kind: "always" },
+        attributes: {},
+    },
+    DependencyCall: {
+        name: "dependency.call",
+        kind: "operation",
+        defaultSeverity: "info",
+        mandatory: false,
+        sampling: { kind: "always" },
+        attributes: {
+            "dependency.name": publicRequired,
+            "dependency.operation": publicRequired,
+        },
+    },
+    LlmCall: {
+        name: "llm.call",
+        kind: "operation",
+        defaultSeverity: "info",
+        mandatory: false,
+        sampling: { kind: "always" },
+        attributes: {
+            "llm.provider": publicRequired,
+            "llm.model": publicRequired,
+            "llm.operation": publicRequired,
+        },
+    },
+    SchedulerRun: {
+        name: "scheduler.run",
+        kind: "operation",
+        defaultSeverity: "info",
+        mandatory: true,
+        sampling: { kind: "always" },
+        attributes: { "scheduler.job": publicRequired },
+    },
+    QueueJob: {
+        name: "queue.job",
+        kind: "operation",
+        defaultSeverity: "info",
+        mandatory: false,
+        sampling: { kind: "always" },
+        attributes: {
+            "queue.name": publicRequired,
+            "queue.job": publicRequired,
+        },
+    },
+    PaymentAttempt: {
+        name: "payment.attempt",
+        kind: "operation",
+        defaultSeverity: "info",
+        mandatory: true,
+        sampling: { kind: "always" },
+        attributes: {
+            "payment.provider": publicRequired,
+            "payment.operation": publicRequired,
+        },
+    },
+    UsageRecorded: {
+        name: "usage.recorded",
+        kind: "domain",
+        defaultSeverity: "info",
+        mandatory: false,
+        sampling: { kind: "always" },
+        attributes: {
+            "usage.type": publicRequired,
+            "usage.unit": publicRequired,
+        },
+    },
+    AuditRecorded: {
+        name: "audit.recorded",
+        kind: "audit",
+        defaultSeverity: "info",
+        mandatory: true,
+        sampling: { kind: "always" },
+        attributes: {},
+    },
+    BrowserError: {
+        name: "browser.error",
+        kind: "defect",
+        defaultSeverity: "error",
+        mandatory: true,
+        sampling: { kind: "always" },
+        attributes: { "error.origin": publicRequired },
+    },
+});

package/dist/contract/TelemetryContract.d.ts

@@ -0,0 +1,95 @@
+import { Effect, Schema } from "effect";
+import { AuditAction, AuditOutcome } from "../audit/AuditRecord.js";
+import { EventName } from "./EventName.js";
+import { type EventKind as EventKindType, type EventSeverity as EventSeverityType, type EventAttributes } from "./TelemetryEvent.js";
+import { InvalidTelemetryContract, InvalidTelemetryEvent } from "./TelemetryContractError.js";
+import { type CompiledMetricDefinition, type MetricDefinitionsInput } from "./MetricDefinition.js";
+export type { CounterMetricDefinitionInput, HistogramMetricDefinitionInput, MetricAttributeDefinitionInput, MetricDefinitionInput, MetricDefinitionsInput, MetricKind, ObservableGaugeMetricDefinitionInput, } from "./MetricDefinition.js";
+export { isValidMetricName } from "./MetricDefinition.js";
+export declare const AttributeClassification: Schema.Literals<readonly ["public", "internal", "sensitive", "forbidden"]>;
+export type AttributeClassification = typeof AttributeClassification.Type;
+export type AttributeDefinition = {
+    readonly classification: AttributeClassification;
+    readonly required: boolean;
+    readonly metricLabel: boolean;
+};
+export type AttributeDefinitionsInput = {
+    readonly [attributeName: string]: AttributeDefinition;
+};
+export type SamplingPolicyInput = {
+    readonly kind: "always";
+} | {
+    readonly kind: "rate";
+    readonly rate: number;
+};
+export type EventDefinitionInput = {
+    readonly name: string;
+    readonly kind: EventKindType;
+    readonly defaultSeverity: EventSeverityType;
+    readonly mandatory: boolean;
+    readonly sampling: SamplingPolicyInput;
+    readonly attributes: AttributeDefinitionsInput;
+};
+export type EventDefinitionsInput = {
+    readonly [alias: string]: EventDefinitionInput;
+};
+export declare const defineEventDefinitions: <const Events extends EventDefinitionsInput>(events: Events) => Events;
+export type AuditActionDefinitionInput = {
+    readonly action: string;
+    readonly resourceType: string;
+    readonly allowedOutcomes: ReadonlyArray<AuditOutcome>;
+    readonly reasonCodes?: ReadonlyArray<string>;
+};
+export type AuditActionDefinitionsInput = {
+    readonly [alias: string]: AuditActionDefinitionInput;
+};
+export type TelemetryContractInput = {
+    readonly version: number;
+    readonly events: EventDefinitionsInput;
+    readonly metrics: MetricDefinitionsInput;
+    readonly auditActions: AuditActionDefinitionsInput;
+};
+export declare const telemetryContractDefinition: <const Definition extends TelemetryContractInput>(definition: Definition) => Definition;
+type StaticEventNames<Definition extends TelemetryContractInput> = {
+    readonly events: {
+        readonly [Alias in keyof Definition["events"]]: string extends Definition["events"][Alias]["name"] ? never : Definition["events"][Alias];
+    };
+};
+export type CompiledEventDefinition = {
+    readonly alias: string;
+    readonly name: EventName;
+    readonly kind: EventKindType;
+    readonly defaultSeverity: EventSeverityType;
+    readonly mandatory: boolean;
+    readonly sampling: SamplingPolicyInput;
+    readonly attributes: ReadonlyMap<string, AttributeDefinition>;
+    readonly requiredAttributes: ReadonlyArray<string>;
+};
+export type AuditActionDefinition = {
+    readonly action: AuditAction;
+    readonly resourceType: string;
+    readonly allowedOutcomes: ReadonlyArray<AuditOutcome>;
+    readonly reasonCodes: ReadonlyArray<string>;
+};
+export type CompiledAuditActionDefinition = AuditActionDefinition & {
+    readonly alias: string;
+};
+export type EventContractRegistry = {
+    readonly eventByName: ReadonlyMap<EventName, CompiledEventDefinition>;
+};
+export declare const validateContractEvent: (contract: EventContractRegistry, eventName: string, attributes: EventAttributes) => CompiledEventDefinition | InvalidTelemetryEvent;
+export type TelemetryContract<Definition extends TelemetryContractInput> = {
+    readonly version: number;
+    readonly definition: Definition;
+    readonly provenance: string;
+    readonly eventNames: ReadonlyArray<EventName>;
+    readonly eventByAlias: ReadonlyMap<string, CompiledEventDefinition>;
+    readonly eventByName: ReadonlyMap<EventName, CompiledEventDefinition>;
+    readonly auditActionByAlias: ReadonlyMap<string, CompiledAuditActionDefinition>;
+    readonly auditActionByName: ReadonlyMap<string, CompiledAuditActionDefinition>;
+    readonly metrics: Definition["metrics"];
+    readonly metricByAlias: ReadonlyMap<string, CompiledMetricDefinition>;
+    readonly metricByName: ReadonlyMap<string, CompiledMetricDefinition>;
+};
+export declare const telemetryContractProvenance: <Definition extends TelemetryContractInput>(contract: TelemetryContract<Definition>) => string;
+export declare const defineTelemetryContract: <const Definition extends TelemetryContractInput>(definition: Definition & StaticEventNames<Definition>) => Effect.Effect<TelemetryContract<Definition>, InvalidTelemetryContract, never>;