@noego/telemetry 0.0.1

package/dist/core/index.d.ts

@@ -0,0 +1,168 @@
+import { M as MetadataSnapshotLimits, d as MetadataSnapshot } from '../telemetry_client-BXw8WH_F.js';
+export { c as MetadataRedactionRule, e as MetadataSnapshotStats, T as TelemetryAdmissionPolicy, f as TelemetryAdmissionPriority, b as TelemetryAdmissionResult, a as TelemetryClient, g as TelemetryClientOptions, h as TelemetryClientStatus } from '../telemetry_client-BXw8WH_F.js';
+export { M as MetricDefinitionContract } from '../metric_definition_contract-l4i4SaAp.js';
+import { T as TelemetryEnvelope } from '../envelope.types-rOLpWXRC.js';
+export { a as TelemetryAdmitInput, b as TelemetryEmitInput, c as TelemetryJsonObject, d as TelemetryJsonPrimitive, e as TelemetryJsonValue, f as TelemetryLevel } from '../envelope.types-rOLpWXRC.js';
+import { M as MetricDefinition, f as MetricExtraction, T as TimelineQuery, b as TimelineQueryResponse, c as TelemetryQueryError, d as MetricQuery, e as MetricQueryResponse } from '../query.types-DySoqYop.js';
+export { E as ExtractedMetricSample, g as MetricAggregate, h as MetricBucket, i as MetricCardinalityRule, a as MetricExtractionFailure, j as MetricMeasurement, k as MetricOverflowPolicy, l as MetricQueryGap, m as MetricQuerySegment, n as MetricRollupValues, R as ResolvedTelemetryConfiguration, o as SqliteMaintenanceConfiguration, p as SqliteRetentionConfiguration, q as SqliteSchemaConfiguration, r as SqliteTableOverrides, S as SqliteTargetConfiguration, s as TelemetryRole, t as TimelineGap } from '../query.types-DySoqYop.js';
+import { T as TelemetryResult } from '../result.types-171Huujb.js';
+import { d as TelemetryBatch, e as TelemetryAcknowledgement, a as TelemetryBatchValidationLimits, f as TelemetryDropCounter, T as TelemetryBatchTransport, b as TelemetryBatchTransportCapabilities, i as TelemetryBatchRouterOptions } from '../transport.types-DDnZoKWi.js';
+export { c as TelemetryBatchReceiver, h as TelemetryBatchRoute, g as TelemetryDeliveryMode, j as TelemetryTargetDeliveryState } from '../transport.types-DDnZoKWi.js';
+import { T as TelemetryStorageTransport, a as TelemetryStorageCapabilities, d as TelemetryStorageRouterOptions, S as StoragePersistRequest, M as MaintenanceStageResult, b as StorageTargetStatus } from '../storage.types-BTCGVxOM.js';
+export { c as MaintenanceRunRecord, e as TelemetryStorageTarget } from '../storage.types-BTCGVxOM.js';
+export { D as DEFAULT_METADATA_SNAPSHOT_LIMITS, a as DEFAULT_TELEMETRY_ADMISSION_POLICY, b as DEFAULT_TELEMETRY_BATCH_VALIDATION_LIMITS } from '../client_defaults-B5tC-TgG.js';
+
+declare class BoundedMetadataSnapshotter {
+    private readonly limits;
+    constructor(limits: MetadataSnapshotLimits);
+    snapshot(input: unknown): MetadataSnapshot;
+    private normalize;
+    private normalizeString;
+    private normalizeArray;
+    private normalizeObject;
+    private normalizeError;
+    private readErrorField;
+    private ensureObject;
+    private isJsonObject;
+    private redactionFor;
+    private validateLimits;
+}
+
+declare class MetricExtractor {
+    private readonly definitions;
+    private readonly contract;
+    constructor(definitions: readonly MetricDefinition[]);
+    extract(envelopes: readonly TelemetryEnvelope[]): MetricExtraction;
+    private extractDefinition;
+    private readField;
+    private readTopLevel;
+    private isDimensionValue;
+    private isJsonObject;
+}
+
+declare class TelemetryAcknowledgementContract {
+    exceptionReason(cause: unknown): string;
+    validateAndDetach(batch: TelemetryBatch, value: unknown): TelemetryResult<TelemetryAcknowledgement, string>;
+    private acknowledgementError;
+    private committedAcknowledgementError;
+    private retryableAcknowledgementError;
+    private rejectedAcknowledgementError;
+    private conflictAcknowledgementError;
+    private targetStatesError;
+    private isValidTargetState;
+    private freezeAcknowledgement;
+    private isRecord;
+    private hasExactKeys;
+    private hasExactArrayIndexes;
+    private isBoundedReason;
+    private truncateReason;
+}
+
+declare class TelemetryBatchContract {
+    static readonly schemaVersion = 1;
+    static readonly checksumAlgorithm = "fnv1a64-canonical-json-v1";
+    readonly limits: TelemetryBatchValidationLimits;
+    constructor(limits?: Partial<TelemetryBatchValidationLimits>);
+    create(envelopes: readonly TelemetryEnvelope[], dropCounters: readonly TelemetryDropCounter[]): TelemetryResult<TelemetryBatch, string>;
+    validate(batch: unknown): TelemetryResult<TelemetryBatch, string>;
+    private createChecked;
+    private validateChecked;
+    private validatePayload;
+    private validateEnvelopes;
+    private validateEnvelope;
+    private validateEnvelopeIdentity;
+    private validateEnvelopeValues;
+    private validateMetadata;
+    private validateJsonValue;
+    private validateJsonArray;
+    private validateJsonObject;
+    private validateJsonChildren;
+    private validateDropCounters;
+    private validateDropCounter;
+    private validateFraming;
+    private compareFraming;
+    private checksumPayload;
+    private serializedByteError;
+    private payloadBytesError;
+    private metadataBudgetError;
+    private detachBatch;
+    private deepFreeze;
+    private isRecord;
+    private hasExactKeys;
+    private isSequence;
+    private isIdentity;
+    private isLabel;
+    private isMonotonicTimestamp;
+    private isConversationId;
+    private isOptionalBoundedString;
+    private isWithinUtf8Limit;
+    private validateLimits;
+}
+
+declare class TelemetryBatchRouter implements TelemetryBatchTransport {
+    private readonly options;
+    readonly transportId: string;
+    readonly capabilities: TelemetryBatchTransportCapabilities;
+    private readonly acknowledgementContract;
+    private readonly deadlineGuard;
+    private readonly committed;
+    constructor(options: TelemetryBatchRouterOptions);
+    send(batch: TelemetryBatch): Promise<TelemetryAcknowledgement>;
+    flush(deadlineMs: number): Promise<void>;
+    close(deadlineMs: number): Promise<void>;
+    private runLifecycleUntilDeadline;
+    private sendMatchingRoutes;
+    private aggregateAcknowledgement;
+    private deliveryStates;
+    private sendSafely;
+    private invalidAcknowledgement;
+    private alreadyCommitted;
+    private deliveryState;
+    private unmatchedStates;
+    private validateRoutes;
+    private remember;
+}
+
+declare class TelemetryStorageRouter implements TelemetryStorageTransport {
+    private readonly options;
+    readonly targetId: string;
+    readonly capabilities: TelemetryStorageCapabilities;
+    private readonly acknowledgementContract;
+    private readonly deadlineGuard;
+    private readonly committed;
+    private readonly definitionTargets;
+    private state;
+    private detail;
+    constructor(options: TelemetryStorageRouterOptions);
+    start(definitions: readonly MetricDefinition[]): Promise<TelemetryResult<void, string>>;
+    persist(request: StoragePersistRequest): Promise<TelemetryAcknowledgement>;
+    timeline(query: TimelineQuery): Promise<TelemetryResult<TimelineQueryResponse, TelemetryQueryError>>;
+    metrics(query: MetricQuery): Promise<TelemetryResult<MetricQueryResponse, TelemetryQueryError>>;
+    materializeRollups(nowMs: number, maxWorkMs: number): Promise<TelemetryResult<MaintenanceStageResult, string>>;
+    enforceRetention(nowMs: number, shouldContinue?: () => boolean): Promise<TelemetryResult<MaintenanceStageResult, string>>;
+    checkpoint(): Promise<TelemetryResult<MaintenanceStageResult, string>>;
+    reclaim(maxPages: number): Promise<TelemetryResult<MaintenanceStageResult, string>>;
+    compact(deadlineMs: number): Promise<TelemetryResult<MaintenanceStageResult, string>>;
+    status(): StorageTargetStatus;
+    stop(deadlineMs: number): Promise<void>;
+    targetStatuses(): readonly StorageTargetStatus[];
+    private startTarget;
+    private rollbackAttemptedTargets;
+    private stopRollbackTarget;
+    private persistMatchingTargets;
+    private aggregateAcknowledgement;
+    private deliveryStates;
+    private requestForTarget;
+    private persistSafely;
+    private invalidAcknowledgement;
+    private alreadyCommitted;
+    private deliveryState;
+    private unmatchedStates;
+    private resolveQueryTarget;
+    private runMaintenance;
+    private validateOptions;
+    private remember;
+    private errorMessage;
+}
+
+export { BoundedMetadataSnapshotter, MaintenanceStageResult, MetadataSnapshot, MetadataSnapshotLimits, MetricDefinition, MetricExtraction, MetricExtractor, MetricQuery, MetricQueryResponse, StoragePersistRequest, StorageTargetStatus, TelemetryAcknowledgement, TelemetryAcknowledgementContract, TelemetryBatch, TelemetryBatchContract, TelemetryBatchRouter, TelemetryBatchRouterOptions, TelemetryBatchTransport, TelemetryBatchTransportCapabilities, TelemetryBatchValidationLimits, TelemetryDropCounter, TelemetryEnvelope, TelemetryQueryError, TelemetryResult, TelemetryStorageCapabilities, TelemetryStorageRouter, TelemetryStorageRouterOptions, TelemetryStorageTransport, TimelineQuery, TimelineQueryResponse };