@uploadista/observability 0.0.3

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> @uploadista/observability@0.0.2 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/observability
+> tsc -b
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 uploadista
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/core/errors.d.ts

@@ -0,0 +1,8 @@
+import { Effect } from "effect";
+import type { StorageMetrics } from "./metrics.js";
+export type StorageErrorCategory = "network_error" | "authentication_error" | "authorization_error" | "throttling_error" | "server_error" | "client_error" | "unknown_error";
+export declare const classifyStorageError: (error: unknown) => StorageErrorCategory;
+export declare const createStorageErrorClassifier: (storageType: string, customErrorMapping?: (error: unknown) => StorageErrorCategory | null) => (error: unknown) => StorageErrorCategory;
+export declare const trackStorageError: (storageType: string, metrics: StorageMetrics, operation: string, error: unknown, context?: Record<string, unknown>, errorClassifier?: (error: unknown) => StorageErrorCategory) => Effect.Effect<void, never, never>;
+export declare const createStorageErrorTracker: (storageType: string, metrics: StorageMetrics, customErrorClassifier?: (error: unknown) => StorageErrorCategory | null) => (operation: string, error: unknown, context?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/core/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAMnD,MAAM,MAAM,oBAAoB,GAC5B,eAAe,GACf,sBAAsB,GACtB,qBAAqB,GACrB,kBAAkB,GAClB,cAAc,GACd,cAAc,GACd,eAAe,CAAC;AAGpB,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,KAAG,oBAmFrD,CAAC;AAGF,eAAO,MAAM,4BAA4B,GACvC,aAAa,MAAM,EACnB,qBAAqB,CAAC,KAAK,EAAE,OAAO,KAAK,oBAAoB,GAAG,IAAI,MAE5D,OAAO,OAAO,KAAG,oBAU1B,CAAC;AAGF,eAAO,MAAM,iBAAiB,GAC5B,aAAa,MAAM,EACnB,SAAS,cAAc,EACvB,WAAW,MAAM,EACjB,OAAO,OAAO,EACd,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACrC,0BA7G0C,OAAO,KAAG,oBA6Gd,sCAkCpC,CAAC;AAGL,eAAO,MAAM,yBAAyB,GACpC,aAAa,MAAM,EACnB,SAAS,cAAc,EACvB,wBAAwB,CAAC,KAAK,EAAE,OAAO,KAAK,oBAAoB,GAAG,IAAI,MAQrE,WAAW,MAAM,EACjB,OAAO,OAAO,EACd,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,sCAUxC,CAAC"}

package/dist/core/errors.js

@@ -0,0 +1,108 @@
+import { Effect, Metric } from "effect";
+// Generic error classifier - can be extended per storage type
+export const classifyStorageError = (error) => {
+    if (!error || typeof error !== "object")
+        return "unknown_error";
+    const errorCode = "code" in error ? error.code : undefined;
+    const errorName = "name" in error ? error.name : undefined;
+    const errorMessage = error instanceof Error ? error.message.toLowerCase() : "";
+    // Network errors (common across all storage types)
+    if (errorCode === "NetworkError" ||
+        errorCode === "ECONNRESET" ||
+        errorCode === "ENOTFOUND" ||
+        errorCode === "ETIMEDOUT" ||
+        errorMessage.indexOf("network") >= 0 ||
+        errorMessage.indexOf("timeout") >= 0) {
+        return "network_error";
+    }
+    // Authentication errors (common patterns)
+    if (errorCode === "InvalidAccessKeyId" ||
+        errorCode === "SignatureDoesNotMatch" ||
+        errorCode === "TokenRefreshRequired" ||
+        errorCode === "AuthenticationFailed" ||
+        errorName === "AuthenticationError" ||
+        errorMessage.indexOf("authentication") >= 0 ||
+        errorMessage.indexOf("unauthorized") >= 0) {
+        return "authentication_error";
+    }
+    // Authorization errors
+    if (errorCode === "AccessDenied" ||
+        errorCode === "AccountProblem" ||
+        errorCode === "Forbidden" ||
+        errorName === "AuthorizationError" ||
+        errorMessage.indexOf("forbidden") >= 0 ||
+        errorMessage.indexOf("permission") >= 0) {
+        return "authorization_error";
+    }
+    // Throttling errors
+    if (errorCode === "SlowDown" ||
+        errorCode === "RequestTimeTooSkewed" ||
+        errorCode === "TooManyRequests" ||
+        errorName === "ThrottlingError" ||
+        errorMessage.indexOf("throttl") >= 0 ||
+        errorMessage.indexOf("rate limit") >= 0) {
+        return "throttling_error";
+    }
+    // Server errors
+    if (errorCode === "InternalError" ||
+        errorCode === "ServiceUnavailable" ||
+        errorCode === "InternalServerError" ||
+        errorName === "ServerError" ||
+        errorMessage.indexOf("server error") >= 0 ||
+        errorMessage.indexOf("service unavailable") >= 0) {
+        return "server_error";
+    }
+    // Client errors
+    if (errorCode === "InvalidRequest" ||
+        errorCode === "MalformedXML" ||
+        errorCode === "RequestEntityTooLarge" ||
+        errorCode === "BadRequest" ||
+        errorName === "ClientError" ||
+        errorMessage.indexOf("bad request") >= 0 ||
+        errorMessage.indexOf("invalid") >= 0) {
+        return "client_error";
+    }
+    return "unknown_error";
+};
+// Storage-specific error classifier factory
+export const createStorageErrorClassifier = (storageType, customErrorMapping) => {
+    return (error) => {
+        // Try custom mapping first
+        if (customErrorMapping) {
+            const customResult = customErrorMapping(error);
+            if (customResult !== null)
+                return customResult;
+        }
+        // Fall back to generic classification
+        return classifyStorageError(error);
+    };
+};
+// Generic error tracking function
+export const trackStorageError = (storageType, metrics, operation, error, context = {}, errorClassifier = classifyStorageError) => Effect.gen(function* () {
+    const errorCategory = errorClassifier(error);
+    // Record error metrics
+    const errorMetric = metrics.uploadErrorsTotal.pipe(Metric.tagged("operation", operation), Metric.tagged("error_category", errorCategory));
+    yield* errorMetric(Effect.succeed(1));
+    // Create detailed error context
+    const errorDetails = {
+        storage_type: storageType,
+        operation,
+        error_category: errorCategory,
+        error_type: typeof error,
+        error_message: error instanceof Error ? error.message : String(error),
+        error_code: error && typeof error === "object" && "code" in error
+            ? error.code
+            : undefined,
+        error_name: error && typeof error === "object" && "name" in error
+            ? error.name
+            : undefined,
+        ...context,
+    };
+    // Log structured error
+    yield* Effect.logError(`${storageType.toUpperCase()} ${operation} failed`).pipe(Effect.annotateLogs(errorDetails));
+});
+// Factory for storage-specific error tracking
+export const createStorageErrorTracker = (storageType, metrics, customErrorClassifier) => {
+    const errorClassifier = createStorageErrorClassifier(storageType, customErrorClassifier);
+    return (operation, error, context = {}) => trackStorageError(storageType, metrics, operation, error, context, errorClassifier);
+};

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./errors.js";
+export * from "./layers.js";
+export * from "./logging.js";
+export * from "./metrics.js";
+export * from "./testing.js";
+export * from "./tracing.js";
+export * from "./utilities.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAEA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,8 @@
+// Core observability exports
+export * from "./errors.js";
+export * from "./layers.js";
+export * from "./logging.js";
+export * from "./metrics.js";
+export * from "./testing.js";
+export * from "./tracing.js";
+export * from "./utilities.js";

package/dist/core/layers.d.ts

@@ -0,0 +1,104 @@
+import { Context, Effect, Layer, Option } from "effect";
+import type { StorageMetrics } from "./metrics.js";
+/**
+ * Core observability service providing tracing, metrics, and logging capabilities
+ */
+export interface ObservabilityService {
+    readonly serviceName: string;
+    readonly enabled: boolean;
+}
+declare const Observability_base: Context.TagClass<Observability, "Observability", ObservabilityService>;
+/**
+ * Observability service tag for Effect Context
+ */
+export declare class Observability extends Observability_base {
+}
+/**
+ * Storage observability service extending base observability with storage-specific metrics
+ */
+export interface StorageObservabilityService extends ObservabilityService {
+    readonly storageType: string;
+    readonly metrics: StorageMetrics;
+}
+declare const StorageObservability_base: Context.TagClass<StorageObservability, "StorageObservability", StorageObservabilityService>;
+/**
+ * Storage observability service tag
+ */
+export declare class StorageObservability extends StorageObservability_base {
+}
+/**
+ * Upload observability service for upload-specific operations
+ */
+export interface UploadObservabilityService extends ObservabilityService {
+    readonly metrics: {
+        uploadCreated: Effect.Effect<void>;
+        uploadCompleted: Effect.Effect<void>;
+        uploadFailed: Effect.Effect<void>;
+        chunkUploaded: Effect.Effect<void>;
+    };
+}
+declare const UploadObservability_base: Context.TagClass<UploadObservability, "UploadObservability", UploadObservabilityService>;
+/**
+ * Upload observability service tag
+ */
+export declare class UploadObservability extends UploadObservability_base {
+}
+/**
+ * Flow observability service for flow execution operations
+ */
+export interface FlowObservabilityService extends ObservabilityService {
+    readonly metrics: {
+        flowStarted: Effect.Effect<void>;
+        flowCompleted: Effect.Effect<void>;
+        flowFailed: Effect.Effect<void>;
+        nodeExecuted: Effect.Effect<void>;
+    };
+}
+declare const FlowObservability_base: Context.TagClass<FlowObservability, "FlowObservability", FlowObservabilityService>;
+/**
+ * Flow observability service tag
+ */
+export declare class FlowObservability extends FlowObservability_base {
+}
+/**
+ * Create a base observability layer
+ */
+export declare const makeObservabilityLayer: (serviceName: string, enabled?: boolean) => Layer.Layer<Observability>;
+/**
+ * Create a storage observability layer
+ */
+export declare const makeStorageObservabilityLayer: (storageType: string, metrics: StorageMetrics, enabled?: boolean) => Layer.Layer<StorageObservability>;
+/**
+ * Create an upload observability layer
+ */
+export declare const makeUploadObservabilityLayer: (enabled?: boolean) => Layer.Layer<UploadObservability>;
+/**
+ * Create a flow observability layer
+ */
+export declare const makeFlowObservabilityLayer: (enabled?: boolean) => Layer.Layer<FlowObservability>;
+/**
+ * No-op observability layer (disabled)
+ */
+export declare const ObservabilityDisabled: Layer.Layer<Observability, never, never>;
+/**
+ * No-op storage observability layer
+ */
+export declare const StorageObservabilityDisabled: (storageType: string) => Layer.Layer<StorageObservability, never, never>;
+/**
+ * No-op upload observability layer
+ */
+export declare const UploadObservabilityDisabled: Layer.Layer<UploadObservability, never, never>;
+/**
+ * No-op flow observability layer
+ */
+export declare const FlowObservabilityDisabled: Layer.Layer<FlowObservability, never, never>;
+/**
+ * Check if observability is enabled in the current context
+ */
+export declare const isObservabilityEnabled: Effect.Effect<boolean, never, never>;
+/**
+ * Execute an effect only if observability is enabled
+ */
+export declare const whenObservabilityEnabled: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, R | Observability>;
+export {};
+//# sourceMappingURL=layers.d.ts.map

package/dist/core/layers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layers.d.ts","sourceRoot":"","sources":["../../src/core/layers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAMnD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,kBAGhC;CAAG;AAEN;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,oBAAoB;IACvE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,yBAGvC;CAAG;AAEN;;GAEG;AACH,MAAM,WAAW,0BAA2B,SAAQ,oBAAoB;IACtE,QAAQ,CAAC,OAAO,EAAE;QAChB,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACnC,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACrC,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAClC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;KACpC,CAAC;CACH;;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,wBAGtC;CAAG;AAEN;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IACpE,QAAQ,CAAC,OAAO,EAAE;QAChB,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACjC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACnC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAChC,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;KACnC,CAAC;CACH;;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,sBAGpC;CAAG;AAMN;;GAEG;AACH,eAAO,MAAM,sBAAsB,GACjC,aAAa,MAAM,EACnB,iBAAc,KACb,KAAK,CAAC,KAAK,CAAC,aAAa,CAIxB,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,6BAA6B,GACxC,aAAa,MAAM,EACnB,SAAS,cAAc,EACvB,iBAAc,KACb,KAAK,CAAC,KAAK,CAAC,oBAAoB,CAM/B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,4BAA4B,GACvC,iBAAc,KACb,KAAK,CAAC,KAAK,CAAC,mBAAmB,CAU9B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,0BAA0B,GACrC,iBAAc,KACb,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAU5B,CAAC;AAML;;GAEG;AACH,eAAO,MAAM,qBAAqB,0CAGjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,4BAA4B,GAAI,aAAa,MAAM,oDAK7D,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,2BAA2B,gDAAsC,CAAC;AAE/E;;GAEG;AACH,eAAO,MAAM,yBAAyB,8CAAoC,CAAC;AAM3E;;GAEG;AACH,eAAO,MAAM,sBAAsB,sCAMjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC9C,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC7B,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,aAAa,CAQnD,CAAC"}

package/dist/core/layers.js

@@ -0,0 +1,110 @@
+import { Context, Effect, Layer, Option } from "effect";
+/**
+ * Observability service tag for Effect Context
+ */
+export class Observability extends Context.Tag("Observability")() {
+}
+/**
+ * Storage observability service tag
+ */
+export class StorageObservability extends Context.Tag("StorageObservability")() {
+}
+/**
+ * Upload observability service tag
+ */
+export class UploadObservability extends Context.Tag("UploadObservability")() {
+}
+/**
+ * Flow observability service tag
+ */
+export class FlowObservability extends Context.Tag("FlowObservability")() {
+}
+// ============================================================================
+// Layer Factories
+// ============================================================================
+/**
+ * Create a base observability layer
+ */
+export const makeObservabilityLayer = (serviceName, enabled = true) => Layer.succeed(Observability, {
+    serviceName,
+    enabled,
+});
+/**
+ * Create a storage observability layer
+ */
+export const makeStorageObservabilityLayer = (storageType, metrics, enabled = true) => Layer.succeed(StorageObservability, {
+    serviceName: `uploadista-${storageType}-store`,
+    storageType,
+    metrics,
+    enabled,
+});
+/**
+ * Create an upload observability layer
+ */
+export const makeUploadObservabilityLayer = (enabled = true) => Layer.succeed(UploadObservability, {
+    serviceName: "uploadista-upload-server",
+    enabled,
+    metrics: {
+        uploadCreated: Effect.void,
+        uploadCompleted: Effect.void,
+        uploadFailed: Effect.void,
+        chunkUploaded: Effect.void,
+    },
+});
+/**
+ * Create a flow observability layer
+ */
+export const makeFlowObservabilityLayer = (enabled = true) => Layer.succeed(FlowObservability, {
+    serviceName: "uploadista-flow-engine",
+    enabled,
+    metrics: {
+        flowStarted: Effect.void,
+        flowCompleted: Effect.void,
+        flowFailed: Effect.void,
+        nodeExecuted: Effect.void,
+    },
+});
+// ============================================================================
+// No-op Layers (for testing and opt-out)
+// ============================================================================
+/**
+ * No-op observability layer (disabled)
+ */
+export const ObservabilityDisabled = makeObservabilityLayer("uploadista-disabled", false);
+/**
+ * No-op storage observability layer
+ */
+export const StorageObservabilityDisabled = (storageType) => makeStorageObservabilityLayer(storageType, {}, // No-op metrics
+false);
+/**
+ * No-op upload observability layer
+ */
+export const UploadObservabilityDisabled = makeUploadObservabilityLayer(false);
+/**
+ * No-op flow observability layer
+ */
+export const FlowObservabilityDisabled = makeFlowObservabilityLayer(false);
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Check if observability is enabled in the current context
+ */
+export const isObservabilityEnabled = Effect.gen(function* () {
+    const observability = yield* Effect.serviceOption(Observability);
+    return Option.match(observability, {
+        onNone: () => false,
+        onSome: (obs) => obs.enabled,
+    });
+});
+/**
+ * Execute an effect only if observability is enabled
+ */
+export const whenObservabilityEnabled = (effect) => Effect.gen(function* () {
+    const enabled = yield* isObservabilityEnabled;
+    if (enabled) {
+        const result = yield* effect;
+        return Option.some(result);
+    }
+    return Option.none();
+});

package/dist/core/logging.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+export declare const logWithContext: (message: string, context: Record<string, unknown>) => Effect.Effect<void, never, never>;
+export declare const logUploadProgress: (storageType: string, uploadId: string, progress: {
+    uploadedBytes: number;
+    totalBytes: number;
+    partNumber?: number;
+    speed?: number;
+}) => Effect.Effect<void, never, never>;
+export declare const logStorageOperation: (storageType: string, operation: string, uploadId: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+export declare const logUploadCompletion: (storageType: string, uploadId: string, metrics: {
+    fileSize: number;
+    totalDurationMs: number;
+    partsCount?: number;
+    averagePartSize?: number;
+    throughputBps?: number;
+    retryCount?: number;
+}) => Effect.Effect<void, never, never>;
+//# sourceMappingURL=logging.d.ts.map

package/dist/core/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../src/core/logging.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMhC,eAAO,MAAM,cAAc,GACzB,SAAS,MAAM,EACf,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,sCACyB,CAAC;AAE5D,eAAO,MAAM,iBAAiB,GAC5B,aAAa,MAAM,EACnB,UAAU,MAAM,EAChB,UAAU;IACR,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,sCAYC,CAAC;AAEL,eAAO,MAAM,mBAAmB,GAC9B,aAAa,MAAM,EACnB,WAAW,MAAM,EACjB,UAAU,MAAM,EAChB,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,sCAOhC,CAAC;AAEL,eAAO,MAAM,mBAAmB,GAC9B,aAAa,MAAM,EACnB,UAAU,MAAM,EAChB,SAAS;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,sCAwBF,CAAC"}

package/dist/core/logging.js

@@ -0,0 +1,41 @@
+import { Effect } from "effect";
+// ============================================================================
+// Enhanced Logging Helpers (Storage-agnostic)
+// ============================================================================
+export const logWithContext = (message, context) => Effect.log(message).pipe(Effect.annotateLogs(context));
+export const logUploadProgress = (storageType, uploadId, progress) => logWithContext("Upload progress", {
+    storage_type: storageType,
+    upload_id: uploadId,
+    uploaded_bytes: progress.uploadedBytes,
+    total_bytes: progress.totalBytes,
+    progress_percentage: Math.round((progress.uploadedBytes / progress.totalBytes) * 100),
+    ...(progress.partNumber && { part_number: progress.partNumber }),
+    ...(progress.speed && { upload_speed_bps: progress.speed }),
+});
+export const logStorageOperation = (storageType, operation, uploadId, metadata) => logWithContext(`${storageType.toUpperCase()} ${operation}`, {
+    storage_type: storageType,
+    operation,
+    upload_id: uploadId,
+    ...metadata,
+});
+export const logUploadCompletion = (storageType, uploadId, metrics) => {
+    const throughputMBps = metrics.throughputBps
+        ? metrics.throughputBps / (1024 * 1024)
+        : 0;
+    return logWithContext(`${storageType.toUpperCase()} upload completed`, {
+        storage_type: storageType,
+        upload_id: uploadId,
+        file_size_bytes: metrics.fileSize,
+        file_size_mb: Math.round((metrics.fileSize / (1024 * 1024)) * 100) / 100,
+        total_duration_ms: metrics.totalDurationMs,
+        total_duration_seconds: Math.round((metrics.totalDurationMs / 1000) * 100) / 100,
+        throughput_bps: metrics.throughputBps,
+        throughput_mbps: Math.round(throughputMBps * 100) / 100,
+        ...(metrics.partsCount && { parts_count: metrics.partsCount }),
+        ...(metrics.averagePartSize && {
+            average_part_size_bytes: metrics.averagePartSize,
+            average_part_size_mb: Math.round((metrics.averagePartSize / (1024 * 1024)) * 100) / 100,
+        }),
+        ...(metrics.retryCount && { retry_count: metrics.retryCount }),
+    });
+};

package/dist/core/metrics.d.ts

@@ -0,0 +1,37 @@
+import { Metric } from "effect";
+export declare const createUploadMetrics: (storageType: string) => {
+    uploadRequestsTotal: Metric.Metric.Counter<number>;
+    uploadPartsTotal: Metric.Metric.Counter<number>;
+    uploadSuccessTotal: Metric.Metric.Counter<number>;
+    uploadErrorsTotal: Metric.Metric.Counter<number>;
+    apiCallsTotal: Metric.Metric.Counter<number>;
+};
+export declare const createUploadHistograms: (storageType: string) => {
+    uploadDurationHistogram: Metric.Metric<import("effect/MetricKeyType").MetricKeyType.Histogram, number, import("effect/MetricState").MetricState.Histogram>;
+    partUploadDurationHistogram: Metric.Metric<import("effect/MetricKeyType").MetricKeyType.Histogram, number, import("effect/MetricState").MetricState.Histogram>;
+    fileSizeHistogram: Metric.Metric<import("effect/MetricKeyType").MetricKeyType.Histogram, number, import("effect/MetricState").MetricState.Histogram>;
+    partSizeHistogram: Metric.Metric<import("effect/MetricKeyType").MetricKeyType.Histogram, number, import("effect/MetricState").MetricState.Histogram>;
+};
+export declare const createUploadGauges: (storageType: string) => {
+    activeUploadsGauge: Metric.Metric.Gauge<number>;
+    uploadThroughputGauge: Metric.Metric.Gauge<number>;
+};
+export declare const createUploadSummaries: (storageType: string) => {
+    uploadLatencySummary: Metric.Metric.Summary<number>;
+};
+export declare const createStorageMetrics: (storageType: string) => {
+    uploadLatencySummary: Metric.Metric.Summary<number>;
+    activeUploadsGauge: Metric.Metric.Gauge<number>;
+    uploadThroughputGauge: Metric.Metric.Gauge<number>;
+    uploadDurationHistogram: Metric.Metric<import("effect/MetricKeyType").MetricKeyType.Histogram, number, import("effect/MetricState").MetricState.Histogram>;
+    partUploadDurationHistogram: Metric.Metric<import("effect/MetricKeyType").MetricKeyType.Histogram, number, import("effect/MetricState").MetricState.Histogram>;
+    fileSizeHistogram: Metric.Metric<import("effect/MetricKeyType").MetricKeyType.Histogram, number, import("effect/MetricState").MetricState.Histogram>;
+    partSizeHistogram: Metric.Metric<import("effect/MetricKeyType").MetricKeyType.Histogram, number, import("effect/MetricState").MetricState.Histogram>;
+    uploadRequestsTotal: Metric.Metric.Counter<number>;
+    uploadPartsTotal: Metric.Metric.Counter<number>;
+    uploadSuccessTotal: Metric.Metric.Counter<number>;
+    uploadErrorsTotal: Metric.Metric.Counter<number>;
+    apiCallsTotal: Metric.Metric.Counter<number>;
+};
+export type StorageMetrics = ReturnType<typeof createStorageMetrics>;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/core/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../src/core/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAoB,MAAM,QAAQ,CAAC;AAOlD,eAAO,MAAM,mBAAmB,GAAI,aAAa,MAAM;;;;;;CAoBrD,CAAC;AAGH,eAAO,MAAM,sBAAsB,GAAI,aAAa,MAAM;;;;;CAwCxD,CAAC;AAGH,eAAO,MAAM,kBAAkB,GAAI,aAAa,MAAM;;;CAWpD,CAAC;AAGH,eAAO,MAAM,qBAAqB,GAAI,aAAa,MAAM;;CASvD,CAAC;AAGH,eAAO,MAAM,oBAAoB,GAAI,aAAa,MAAM;;;;;;;;;;;;;CAKtD,CAAC;AAGH,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/core/metrics.js

@@ -0,0 +1,72 @@
+import { Metric, MetricBoundaries } from "effect";
+// ============================================================================
+// Core Storage Metrics (reusable across all storage types)
+// ============================================================================
+// Counter metrics
+export const createUploadMetrics = (storageType) => ({
+    uploadRequestsTotal: Metric.counter(`${storageType}_upload_requests_total`, {
+        description: `Total number of upload requests for ${storageType}`,
+    }),
+    uploadPartsTotal: Metric.counter(`${storageType}_upload_parts_total`, {
+        description: `Total number of individual parts uploaded for ${storageType}`,
+    }),
+    uploadSuccessTotal: Metric.counter(`${storageType}_upload_success_total`, {
+        description: `Total number of successful uploads for ${storageType}`,
+    }),
+    uploadErrorsTotal: Metric.counter(`${storageType}_upload_errors_total`, {
+        description: `Total number of upload errors for ${storageType}`,
+    }),
+    apiCallsTotal: Metric.counter(`${storageType}_api_calls_total`, {
+        description: `Total number of API calls for ${storageType}`,
+    }),
+});
+// Histogram metrics for timing and sizes (reusable)
+export const createUploadHistograms = (storageType) => ({
+    uploadDurationHistogram: Metric.histogram(`${storageType}_upload_duration_seconds`, MetricBoundaries.exponential({
+        start: 0.01, // 10ms
+        factor: 2,
+        count: 20, // Up to ~10 seconds
+    }), `Duration of upload operations in seconds for ${storageType}`),
+    partUploadDurationHistogram: Metric.histogram(`${storageType}_part_upload_duration_seconds`, MetricBoundaries.exponential({
+        start: 0.001, // 1ms
+        factor: 2,
+        count: 15, // Up to ~32 seconds
+    }), `Duration of individual part uploads in seconds for ${storageType}`),
+    fileSizeHistogram: Metric.histogram(`${storageType}_file_size_bytes`, MetricBoundaries.exponential({
+        start: 1024, // 1KB
+        factor: 2,
+        count: 25, // Up to ~33GB
+    }), `Size of uploaded files in bytes for ${storageType}`),
+    partSizeHistogram: Metric.histogram(`${storageType}_part_size_bytes`, MetricBoundaries.linear({
+        start: 5_242_880, // 5MB (minimum part size)
+        width: 1_048_576, // 1MB increments
+        count: 20, // Up to ~25MB
+    }), `Size of upload parts in bytes for ${storageType}`),
+});
+// Gauge metrics for current state (reusable)
+export const createUploadGauges = (storageType) => ({
+    activeUploadsGauge: Metric.gauge(`${storageType}_active_uploads`, {
+        description: `Number of currently active uploads for ${storageType}`,
+    }),
+    uploadThroughputGauge: Metric.gauge(`${storageType}_upload_throughput_bytes_per_second`, {
+        description: `Current upload throughput in bytes per second for ${storageType}`,
+    }),
+});
+// Summary metrics for percentiles (reusable)
+export const createUploadSummaries = (storageType) => ({
+    uploadLatencySummary: Metric.summary({
+        name: `${storageType}_upload_latency_seconds`,
+        maxAge: "10 minutes",
+        maxSize: 1000,
+        error: 0.01,
+        quantiles: [0.5, 0.9, 0.95, 0.99],
+        description: `Upload latency percentiles for ${storageType}`,
+    }),
+});
+// Combined metrics factory
+export const createStorageMetrics = (storageType) => ({
+    ...createUploadMetrics(storageType),
+    ...createUploadHistograms(storageType),
+    ...createUploadGauges(storageType),
+    ...createUploadSummaries(storageType),
+});

package/dist/core/testing.d.ts

@@ -0,0 +1,43 @@
+import { Effect, Layer } from "effect";
+import { FlowObservability, StorageObservability, UploadObservability } from "./layers.js";
+/**
+ * Mock storage observability for testing
+ */
+export declare const makeTestStorageObservability: (storageType: string) => Layer.Layer<StorageObservability>;
+/**
+ * Mock upload observability for testing
+ */
+export declare const makeTestUploadObservability: () => Layer.Layer<UploadObservability>;
+/**
+ * Mock flow observability for testing
+ */
+export declare const makeTestFlowObservability: () => Layer.Layer<FlowObservability>;
+/**
+ * Capture metrics snapshot from an effect for testing
+ * Note: Metric snapshots are simplified - for full metric testing,
+ * use Effect's built-in metric testing utilities
+ */
+export declare const captureMetrics: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Test helper to capture metrics around effect execution
+ * This is a simplified version - for production testing,
+ * use Effect's metric testing utilities
+ */
+export declare const withMetricTracking: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Test fixture for observability testing
+ */
+export interface ObservabilityTestFixture {
+    readonly storageObservability: Layer.Layer<StorageObservability>;
+    readonly uploadObservability: Layer.Layer<UploadObservability>;
+    readonly flowObservability: Layer.Layer<FlowObservability>;
+}
+/**
+ * Create a complete test fixture with all observability layers
+ */
+export declare const createTestFixture: (storageType?: string) => ObservabilityTestFixture;
+/**
+ * Run an effect with test observability layers
+ */
+export declare const runWithTestObservability: <A, E>(effect: Effect.Effect<A, E, StorageObservability | UploadObservability | FlowObservability>, storageType?: string) => Effect.Effect<A, E>;
+//# sourceMappingURL=testing.d.ts.map

package/dist/core/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../src/core/testing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAC;AAM/C,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAOrB;;GAEG;AACH,eAAO,MAAM,4BAA4B,GACvC,aAAa,MAAM,KAClB,KAAK,CAAC,KAAK,CAAC,oBAAoB,CASlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B,QAClC,KAAK,CAAC,KAAK,CAAC,mBAAmB,CAYlC,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,yBAAyB,QAAO,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAYzE,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EACpC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC7B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAMpB,CAAC;AAEL;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EACxC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC7B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAQpB,CAAC;AAEL;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,oBAAoB,EAAE,KAAK,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC;IACjE,QAAQ,CAAC,mBAAmB,EAAE,KAAK,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IAC/D,QAAQ,CAAC,iBAAiB,EAAE,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;CAC5D;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,oBAA4B,KAC3B,wBAID,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,EAAE,CAAC,EAC3C,QAAQ,MAAM,CAAC,MAAM,CACnB,CAAC,EACD,CAAC,EACD,oBAAoB,GAAG,mBAAmB,GAAG,iBAAiB,CAC/D,EACD,oBAA4B,KAC3B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAOpB,CAAC"}