@equipe-tech/observability 0.1.0

package/dist/BrowserEvents.d.ts

@@ -0,0 +1,35 @@
+import { Schema } from "effect";
+export declare const maxEventsPerBatch = 64;
+export declare const maxFieldsPerEvent = 32;
+export declare const maxFieldKeyLength = 128;
+export declare const maxFieldValueLength = 1024;
+export declare const maxEventNameLength = 128;
+export declare const maxEventIdLength = 64;
+declare const BrowserEventFields: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>;
+export type BrowserEventFields = typeof BrowserEventFields.Type;
+declare const BrowserEvent_base: Schema.Class<BrowserEvent, Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly name: Schema.NonEmptyString;
+    readonly occurredAt: Schema.Number;
+    readonly fields: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>;
+}>, {}>;
+export declare class BrowserEvent extends BrowserEvent_base {
+}
+declare const BrowserEventBatch_base: Schema.Class<BrowserEventBatch, Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly events: Schema.$Array<typeof BrowserEvent>;
+}>, {}>;
+export declare class BrowserEventBatch extends BrowserEventBatch_base {
+}
+export declare const encodeBrowserEventBatch: (input: BrowserEventBatch, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+    readonly version: 1;
+    readonly events: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly occurredAt: number;
+        readonly fields: {
+            readonly [x: string]: string | number | boolean;
+        };
+    }[];
+}, Schema.SchemaError, never>;
+export {};

package/dist/BrowserEvents.js

@@ -0,0 +1,33 @@
+import { Schema } from "effect";
+export const maxEventsPerBatch = 64;
+export const maxFieldsPerEvent = 32;
+export const maxFieldKeyLength = 128;
+export const maxFieldValueLength = 1024;
+export const maxEventNameLength = 128;
+export const maxEventIdLength = 64;
+const BoundedFieldValue = Schema.Union([
+    Schema.String.check(Schema.isMaxLength(maxFieldValueLength)),
+    Schema.Number.check(Schema.isFinite()),
+    Schema.Boolean,
+]);
+const BoundedFieldKey = Schema.NonEmptyString.check(Schema.isMaxLength(maxFieldKeyLength));
+const BrowserEventFields = Schema.Record(BoundedFieldKey, BoundedFieldValue).check(Schema.makeFilter((fields) => Object.keys(fields).length <= maxFieldsPerEvent, {
+    expected: `at most ${maxFieldsPerEvent} fields per event`,
+}));
+export class BrowserEvent extends Schema.Class("@equipe-tech/observability/BrowserEvent")({
+    id: Schema.NonEmptyString.check(Schema.isMaxLength(maxEventIdLength)),
+    name: Schema.NonEmptyString.check(Schema.isMaxLength(maxEventNameLength)),
+    occurredAt: Schema.Number.check(Schema.isFinite(), Schema.makeFilter((millis) => millis >= 0, {
+        expected: "a non-negative epoch timestamp in milliseconds",
+    })),
+    fields: BrowserEventFields,
+}) {
+}
+export class BrowserEventBatch extends Schema.Class("@equipe-tech/observability/BrowserEventBatch")({
+    version: Schema.Literal(1),
+    events: Schema.Array(BrowserEvent).check(Schema.makeFilter((events) => events.length <= maxEventsPerBatch, {
+        expected: `at most ${maxEventsPerBatch} events per batch`,
+    })),
+}) {
+}
+export const encodeBrowserEventBatch = Schema.encodeEffect(BrowserEventBatch);

package/dist/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/Telemetry.d.ts

@@ -0,0 +1,7 @@
+import { Layer } from "effect";
+import { type HttpClient } from "effect/unstable/http";
+import type { EnvironmentVariables, InvalidTelemetryEnvironment } from "./TelemetryConfig.js";
+import { type TelemetryConfig } from "./TelemetryConfig.js";
+export declare const layerOtlp: (config: TelemetryConfig) => Layer.Layer<never, never, HttpClient.HttpClient>;
+export declare const layer: (config: TelemetryConfig) => Layer.Layer<never>;
+export declare const layerFromEnv: (env: EnvironmentVariables) => Layer.Layer<never, InvalidTelemetryEnvironment>;

package/dist/Telemetry.js

@@ -0,0 +1,16 @@
+import { Effect, Layer } from "effect";
+import { FetchHttpClient } from "effect/unstable/http";
+import { Otlp } from "effect/unstable/observability";
+import { telemetryConfigFromEnv } from "./TelemetryConfig.js";
+export const layerOtlp = (config) => Otlp.layerJson({
+    baseUrl: config.otlpEndpoint.toString(),
+    resource: {
+        serviceName: config.serviceName,
+        serviceVersion: config.serviceVersion,
+        attributes: {
+            "deployment.environment.name": config.environment,
+        },
+    },
+});
+export const layer = (config) => layerOtlp(config).pipe(Layer.provide(FetchHttpClient.layer));
+export const layerFromEnv = (env) => Layer.unwrap(Effect.map(telemetryConfigFromEnv(env), layer));

package/dist/TelemetryConfig.d.ts

@@ -0,0 +1,21 @@
+import { Effect, Schema } from "effect";
+declare const TelemetryConfig_base: Schema.Class<TelemetryConfig, Schema.Struct<{
+    readonly serviceName: Schema.NonEmptyString;
+    readonly serviceVersion: Schema.NonEmptyString;
+    readonly environment: Schema.NonEmptyString;
+    readonly otlpEndpoint: Schema.URLFromString;
+}>, {}>;
+export declare class TelemetryConfig extends TelemetryConfig_base {
+}
+declare const InvalidTelemetryEnvironment_base: Schema.Class<InvalidTelemetryEnvironment, Schema.TaggedStruct<"InvalidTelemetryEnvironment", {
+    readonly code: Schema.Literal<"OBS_TELEMETRY_INVALID_ENVIRONMENT">;
+    readonly message: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidTelemetryEnvironment extends InvalidTelemetryEnvironment_base {
+}
+export type EnvironmentVariables = {
+    readonly [name: string]: string | undefined;
+};
+export declare const telemetryConfigFromEnv: (env: EnvironmentVariables) => Effect.Effect<TelemetryConfig, InvalidTelemetryEnvironment, never>;
+export {};

package/dist/TelemetryConfig.js

@@ -0,0 +1,37 @@
+import { Effect, Schema } from "effect";
+const OtlpEndpoint = Schema.URLFromString.check(Schema.makeFilter((url) => (url.protocol === "http:" || url.protocol === "https:") &&
+    url.username === "" &&
+    url.password === "", { expected: "an HTTP or HTTPS URL without credentials" }));
+export class TelemetryConfig extends Schema.Class("@equipe-tech/observability/TelemetryConfig")({
+    serviceName: Schema.NonEmptyString,
+    serviceVersion: Schema.NonEmptyString,
+    environment: Schema.NonEmptyString,
+    otlpEndpoint: OtlpEndpoint,
+}) {
+}
+export class InvalidTelemetryEnvironment extends Schema.TaggedError()("InvalidTelemetryEnvironment", {
+    code: Schema.Literal("OBS_TELEMETRY_INVALID_ENVIRONMENT"),
+    message: Schema.String,
+    cause: Schema.Defect(),
+}) {
+}
+const TelemetryEnvironment = Schema.Struct({
+    OTEL_SERVICE_NAME: Schema.NonEmptyString,
+    OTEL_SERVICE_VERSION: Schema.NonEmptyString.pipe(Schema.withDecodingDefault(Effect.succeed("0.0.0"))),
+    OTEL_DEPLOYMENT_ENVIRONMENT: Schema.NonEmptyString.pipe(Schema.withDecodingDefault(Effect.succeed("development"))),
+    OTEL_EXPORTER_OTLP_ENDPOINT: OtlpEndpoint.pipe(Schema.withDecodingDefault(Effect.succeed("http://localhost:4318"))),
+});
+const decodeTelemetryEnvironment = Schema.decodeUnknownEffect(TelemetryEnvironment);
+export const telemetryConfigFromEnv = Effect.fn("telemetryConfigFromEnv")(function* (env) {
+    const variables = yield* decodeTelemetryEnvironment(env).pipe(Effect.mapError((cause) => new InvalidTelemetryEnvironment({
+        code: "OBS_TELEMETRY_INVALID_ENVIRONMENT",
+        message: "Telemetry environment is invalid. Set OTEL_SERVICE_NAME and use valid values for the remaining OTEL variables.",
+        cause,
+    })));
+    return new TelemetryConfig({
+        serviceName: variables.OTEL_SERVICE_NAME,
+        serviceVersion: variables.OTEL_SERVICE_VERSION,
+        environment: variables.OTEL_DEPLOYMENT_ENVIRONMENT,
+        otlpEndpoint: variables.OTEL_EXPORTER_OTLP_ENDPOINT,
+    });
+});

package/dist/WideEvent.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+export type WideEventFields = {
+    readonly [attribute: string]: string | number | boolean;
+};
+export declare const emit: (name: string, fields: WideEventFields) => Effect.Effect<void>;

package/dist/WideEvent.js

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+export const emit = (name, fields) => Effect.logInfo(name).pipe(Effect.annotateLogs({
+    ...fields,
+    "event.name": name,
+    "event.kind": "wide",
+}));

package/dist/browser/index.d.ts

@@ -0,0 +1,35 @@
+import { Context, Duration, Effect, Layer, Schema } from "effect";
+import { BrowserEventBatch } from "../BrowserEvents.js";
+import type { WideEventFields } from "../WideEvent.js";
+export { BrowserEvent, BrowserEventBatch, maxEventNameLength, maxEventsPerBatch, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";
+export declare const defaultEventsEndpoint = "/_telemetry/events";
+declare const BrowserEventDeliveryError_base: Schema.Class<BrowserEventDeliveryError, Schema.TaggedStruct<"BrowserEventDeliveryError", {
+    readonly code: Schema.Literal<"OBS_BROWSER_EVENTS_DELIVERY_FAILED">;
+    readonly message: Schema.String;
+    readonly retryable: Schema.Boolean;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class BrowserEventDeliveryError extends BrowserEventDeliveryError_base {
+}
+declare const BrowserEventTransport_base: Context.ServiceClass<BrowserEventTransport, "@equipe-tech/observability/BrowserEventTransport", {
+    send(batch: BrowserEventBatch): Effect.Effect<void, BrowserEventDeliveryError>;
+}>;
+export declare class BrowserEventTransport extends BrowserEventTransport_base {
+    static readonly layerFetch: (options?: {
+        readonly endpoint?: string;
+    }) => Layer.Layer<BrowserEventTransport>;
+}
+export type BrowserTelemetryOptions = {
+    readonly maxBatchSize?: number;
+    readonly maxQueueSize?: number;
+    readonly flushInterval?: Duration.Input;
+};
+declare const BrowserTelemetry_base: Context.ServiceClass<BrowserTelemetry, "@equipe-tech/observability/BrowserTelemetry", {
+    emit(name: string, fields?: WideEventFields): Effect.Effect<void>;
+    flush(): Effect.Effect<void, BrowserEventDeliveryError>;
+    pending(): Effect.Effect<number>;
+    dropped(): Effect.Effect<number>;
+}>;
+export declare class BrowserTelemetry extends BrowserTelemetry_base {
+    static readonly layer: (options?: BrowserTelemetryOptions) => Layer.Layer<BrowserTelemetry, never, BrowserEventTransport>;
+}

package/dist/browser/index.js

@@ -0,0 +1,105 @@
+import { Clock, Context, Duration, Effect, Layer, Predicate, Ref, Schema } from "effect";
+import { BrowserEvent, BrowserEventBatch, encodeBrowserEventBatch, maxEventNameLength, maxEventsPerBatch, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";
+export { BrowserEvent, BrowserEventBatch, maxEventNameLength, maxEventsPerBatch, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "../BrowserEvents.js";
+export const defaultEventsEndpoint = "/_telemetry/events";
+export class BrowserEventDeliveryError extends Schema.TaggedError()("BrowserEventDeliveryError", {
+    code: Schema.Literal("OBS_BROWSER_EVENTS_DELIVERY_FAILED"),
+    message: Schema.String,
+    retryable: Schema.Boolean,
+    cause: Schema.Defect(),
+}) {
+}
+export class BrowserEventTransport extends Context.Service()("@equipe-tech/observability/BrowserEventTransport") {
+    static layerFetch = (options) => {
+        const endpoint = options?.endpoint ?? defaultEventsEndpoint;
+        return Layer.succeed(BrowserEventTransport, BrowserEventTransport.of({
+            send: (batch) => Effect.gen(function* () {
+                const payload = yield* encodeBrowserEventBatch(batch).pipe(Effect.orDie);
+                const response = yield* Effect.tryPromise({
+                    try: (signal) => fetch(endpoint, {
+                        method: "POST",
+                        headers: { "content-type": "application/json" },
+                        body: JSON.stringify(payload),
+                        keepalive: true,
+                        signal,
+                    }),
+                    catch: (cause) => new BrowserEventDeliveryError({
+                        code: "OBS_BROWSER_EVENTS_DELIVERY_FAILED",
+                        message: "The browser events could not be sent. The events stay queued and the next flush retries the same batch.",
+                        retryable: true,
+                        cause,
+                    }),
+                });
+                if (!response.ok) {
+                    return yield* new BrowserEventDeliveryError({
+                        code: "OBS_BROWSER_EVENTS_DELIVERY_FAILED",
+                        message: `The telemetry endpoint rejected the batch with status ${response.status}. Check the /_telemetry/events route of the project API.`,
+                        retryable: response.status === 429 || response.status >= 500,
+                        cause: response.status,
+                    });
+                }
+            }),
+        }));
+    };
+}
+const clampFields = (fields) => {
+    const clamped = {};
+    let count = 0;
+    for (const [key, value] of Object.entries(fields)) {
+        if (key === "" || count >= maxFieldsPerEvent) {
+            continue;
+        }
+        const boundedKey = key.slice(0, maxFieldKeyLength);
+        clamped[boundedKey] = Predicate.isString(value) ? value.slice(0, maxFieldValueLength) : value;
+        count += 1;
+    }
+    return clamped;
+};
+const makeBrowserTelemetry = Effect.fn("makeBrowserTelemetry")(function* (options) {
+    const transport = yield* BrowserEventTransport;
+    const maxBatchSize = Math.min(options?.maxBatchSize ?? 32, maxEventsPerBatch);
+    const maxQueueSize = options?.maxQueueSize ?? 256;
+    const flushInterval = Duration.fromInputUnsafe(options?.flushInterval ?? "5 seconds");
+    const queue = yield* Ref.make({ events: [], dropped: 0 });
+    const emit = (name, fields) => Effect.gen(function* () {
+        const occurredAt = yield* Clock.currentTimeMillis;
+        const event = new BrowserEvent({
+            id: crypto.randomUUID(),
+            name: name.slice(0, maxEventNameLength),
+            occurredAt,
+            fields: clampFields(fields ?? {}),
+        });
+        yield* Ref.update(queue, (state) => state.events.length >= maxQueueSize
+            ? { events: [...state.events.slice(1), event], dropped: state.dropped + 1 }
+            : { events: [...state.events, event], dropped: state.dropped });
+    });
+    const flush = Effect.gen(function* () {
+        while (true) {
+            const batchEvents = yield* Ref.modify(queue, (state) => [
+                state.events.slice(0, maxBatchSize),
+                { events: state.events.slice(maxBatchSize), dropped: state.dropped },
+            ]);
+            if (batchEvents.length === 0) {
+                return;
+            }
+            yield* transport.send(new BrowserEventBatch({ version: 1, events: batchEvents })).pipe(Effect.tapError(() => Ref.update(queue, (state) => {
+                const requeued = [...batchEvents, ...state.events];
+                return {
+                    events: requeued.slice(0, maxQueueSize),
+                    dropped: state.dropped + Math.max(0, requeued.length - maxQueueSize),
+                };
+            })));
+        }
+    });
+    yield* Effect.forkScoped(flush.pipe(Effect.ignore, Effect.delay(flushInterval), Effect.forever));
+    yield* Effect.addFinalizer(() => flush.pipe(Effect.ignore));
+    return {
+        emit,
+        flush: () => flush,
+        pending: () => Ref.get(queue).pipe(Effect.map((state) => state.events.length)),
+        dropped: () => Ref.get(queue).pipe(Effect.map((state) => state.dropped)),
+    };
+});
+export class BrowserTelemetry extends Context.Service()("@equipe-tech/observability/BrowserTelemetry") {
+    static layer = (options) => Layer.effect(BrowserTelemetry, makeBrowserTelemetry(options));
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * as BrowserEvents from "./BrowserEvents.js";
+export * as Telemetry from "./Telemetry.js";
+export { InvalidTelemetryEnvironment, TelemetryConfig, telemetryConfigFromEnv, } from "./TelemetryConfig.js";
+export * as WideEvent from "./WideEvent.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * as BrowserEvents from "./BrowserEvents.js";
+export * as Telemetry from "./Telemetry.js";
+export { InvalidTelemetryEnvironment, TelemetryConfig, telemetryConfigFromEnv, } from "./TelemetryConfig.js";
+export * as WideEvent from "./WideEvent.js";

package/dist/nestjs/BrowserEventsController.d.ts

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+import type { ManagedRuntime } from "effect";
+import { type BrowserEventIngestReceipt } from "../node/BrowserEventIngest.js";
+import { type RequestReference } from "./TelemetryInterceptor.js";
+export declare const defaultBrowserEventsPath = "_telemetry/events";
+declare const BrowserEventsRejection_base: Schema.Class<BrowserEventsRejection, Schema.Struct<{
+    readonly code: Schema.Literal<"OBS_BROWSER_EVENTS_INVALID_BATCH">;
+    readonly message: Schema.String;
+    readonly correlationId: Schema.String;
+}>, {}>;
+export declare class BrowserEventsRejection extends BrowserEventsRejection_base {
+}
+export type BrowserEventsControllerOptions = {
+    readonly path?: string;
+};
+export declare const createBrowserEventsController: <RuntimeError>(runtime: ManagedRuntime.ManagedRuntime<never, RuntimeError>, options?: BrowserEventsControllerOptions) => {
+    new (): {
+        events(request: RequestReference): Promise<BrowserEventIngestReceipt>;
+    };
+};
+export {};

package/dist/nestjs/BrowserEventsController.js

@@ -0,0 +1,44 @@
+import { Controller, HttpCode, HttpException, Post, Req } from "@nestjs/common";
+import { Cause, Exit, Option, Schema } from "effect";
+import { ingestBrowserEvents, InvalidBrowserEventBatch, } from "../node/BrowserEventIngest.js";
+import { requestSpan, withRequestSpan } from "./TelemetryInterceptor.js";
+export const defaultBrowserEventsPath = "_telemetry/events";
+export class BrowserEventsRejection extends Schema.Class("@equipe-tech/observability/BrowserEventsRejection")({
+    code: Schema.Literal("OBS_BROWSER_EVENTS_INVALID_BATCH"),
+    message: Schema.String,
+    correlationId: Schema.String,
+}) {
+}
+const RequestWithBody = Schema.Struct({ body: Schema.Unknown });
+const decodeRequestWithBody = Schema.decodeUnknownOption(RequestWithBody);
+const correlationId = (request) => requestSpan(request).pipe(Option.map((span) => span.traceId), Option.getOrElse(() => crypto.randomUUID()));
+export const createBrowserEventsController = (runtime, options) => {
+    class BrowserEventsController {
+        async events(request) {
+            const body = decodeRequestWithBody(request).pipe(Option.map((parsed) => parsed.body), Option.getOrUndefined);
+            const exit = await runtime.runPromiseExit(ingestBrowserEvents(body).pipe(withRequestSpan(request)));
+            if (Exit.isSuccess(exit)) {
+                return exit.value;
+            }
+            const error = Cause.findErrorOption(exit.cause);
+            if (Option.isSome(error) && error.value instanceof InvalidBrowserEventBatch) {
+                throw new HttpException(new BrowserEventsRejection({
+                    code: error.value.code,
+                    message: error.value.message,
+                    correlationId: correlationId(request),
+                }), 400);
+            }
+            throw Cause.squash(exit.cause);
+        }
+    }
+    const prototype = BrowserEventsController.prototype;
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, "events");
+    if (descriptor === undefined) {
+        throw new Error("The events handler is missing on the controller prototype.");
+    }
+    Controller()(BrowserEventsController);
+    Post(options?.path ?? defaultBrowserEventsPath)(prototype, "events", descriptor);
+    HttpCode(202)(prototype, "events", descriptor);
+    Req()(prototype, "events", 0);
+    return BrowserEventsController;
+};

package/dist/nestjs/TelemetryInterceptor.d.ts

@@ -0,0 +1,12 @@
+import type { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
+import { Effect, Option } from "effect";
+import type { ManagedRuntime, Tracer } from "effect";
+import { Observable } from "rxjs";
+export type RequestReference = WeakKey;
+export declare const requestSpan: (request: RequestReference) => Option.Option<Tracer.Span>;
+export declare const withRequestSpan: (request: RequestReference) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+export declare class TelemetryInterceptor<RuntimeError> implements NestInterceptor {
+    #private;
+    constructor(runtime: ManagedRuntime.ManagedRuntime<never, RuntimeError>);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+}

package/dist/nestjs/TelemetryInterceptor.js

@@ -0,0 +1,102 @@
+import { Context, Effect, Exit, Option, Schema } from "effect";
+import { Observable } from "rxjs";
+const HttpRequestBoundary = Schema.Struct({
+    method: Schema.NonEmptyString,
+});
+const decodeHttpRequestBoundary = Schema.decodeUnknownOption(HttpRequestBoundary);
+const HttpResponseBoundary = Schema.Struct({
+    statusCode: Schema.Number.check(Schema.isInt()),
+});
+const decodeHttpResponseBoundary = Schema.decodeUnknownOption(HttpResponseBoundary);
+const ClientErrorBoundary = Schema.Struct({
+    status: Schema.Number.check(Schema.isInt(), Schema.makeFilter((status) => status >= 400 && status <= 499, {
+        expected: "an HTTP client error status",
+    })),
+});
+const decodeClientErrorBoundary = Schema.decodeUnknownOption(ClientErrorBoundary);
+const requestSpans = new WeakMap();
+export const requestSpan = (request) => Option.fromNullishOr(requestSpans.get(request));
+export const withRequestSpan = (request) => (effect) => Option.match(requestSpan(request), {
+    onNone: () => effect,
+    onSome: (span) => Effect.withParentSpan(effect, span),
+});
+export class TelemetryInterceptor {
+    #runtime;
+    #tracer;
+    #clock;
+    constructor(runtime) {
+        this.#runtime = runtime;
+    }
+    intercept(context, next) {
+        if (context.getType() !== "http") {
+            return next.handle();
+        }
+        try {
+            return this.#instrument(context, next);
+        }
+        catch {
+            return next.handle();
+        }
+    }
+    #instrument(context, next) {
+        const tracer = (this.#tracer ??= this.#runtime.runSync(Effect.tracer));
+        const clock = (this.#clock ??= this.#runtime.runSync(Effect.clockWith(Effect.succeed)));
+        const httpContext = context.switchToHttp();
+        const request = httpContext.getRequest();
+        const method = decodeHttpRequestBoundary(request).pipe(Option.map((boundary) => boundary.method.toUpperCase()), Option.getOrElse(() => "UNKNOWN"));
+        const controller = context.getClass().name;
+        const handler = context.getHandler().name;
+        const span = tracer.span({
+            name: `${method} ${controller}.${handler}`,
+            parent: Option.none(),
+            annotations: Context.empty(),
+            links: [],
+            startTime: clock.currentTimeNanosUnsafe(),
+            kind: "server",
+            root: true,
+            sampled: true,
+        });
+        span.attribute("http.request.method", method);
+        span.attribute("nestjs.controller", controller);
+        span.attribute("nestjs.handler", handler);
+        requestSpans.set(request, span);
+        return new Observable((subscriber) => {
+            let settled = false;
+            const finish = (exit, statusOverride) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                const status = statusOverride.pipe(Option.orElse(() => decodeHttpResponseBoundary(httpContext.getResponse()).pipe(Option.map((boundary) => boundary.statusCode))));
+                if (Option.isSome(status)) {
+                    span.attribute("http.response.status_code", status.value);
+                }
+                span.end(clock.currentTimeNanosUnsafe(), exit);
+            };
+            const subscription = next.handle().subscribe({
+                next: (value) => subscriber.next(value),
+                error: (cause) => {
+                    const clientError = decodeClientErrorBoundary(cause);
+                    if (Option.isSome(clientError)) {
+                        finish(Exit.succeed(undefined), Option.some(clientError.value.status));
+                    }
+                    else {
+                        finish(Exit.die(cause), Option.none());
+                    }
+                    subscriber.error(cause);
+                },
+                complete: () => {
+                    finish(Exit.succeed(undefined), Option.none());
+                    subscriber.complete();
+                },
+            });
+            return () => {
+                if (!settled) {
+                    span.attribute("http.request.cancelled", true);
+                    finish(Exit.interrupt(), Option.none());
+                }
+                subscription.unsubscribe();
+            };
+        });
+    }
+}

package/dist/nestjs/index.d.ts

@@ -0,0 +1,2 @@
+export { BrowserEventsRejection, createBrowserEventsController, defaultBrowserEventsPath, type BrowserEventsControllerOptions, } from "./BrowserEventsController.js";
+export { requestSpan, TelemetryInterceptor, withRequestSpan, type RequestReference, } from "./TelemetryInterceptor.js";

package/dist/nestjs/index.js

@@ -0,0 +1,2 @@
+export { BrowserEventsRejection, createBrowserEventsController, defaultBrowserEventsPath, } from "./BrowserEventsController.js";
+export { requestSpan, TelemetryInterceptor, withRequestSpan, } from "./TelemetryInterceptor.js";

package/dist/node/BrowserEventIngest.d.ts

@@ -0,0 +1,16 @@
+import { Effect, Schema } from "effect";
+import { BrowserEventBatch } from "../BrowserEvents.js";
+declare const InvalidBrowserEventBatch_base: Schema.Class<InvalidBrowserEventBatch, Schema.TaggedStruct<"InvalidBrowserEventBatch", {
+    readonly code: Schema.Literal<"OBS_BROWSER_EVENTS_INVALID_BATCH">;
+    readonly message: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidBrowserEventBatch extends InvalidBrowserEventBatch_base {
+}
+export declare const parseBrowserEventBatch: (input: unknown) => Effect.Effect<BrowserEventBatch, InvalidBrowserEventBatch>;
+export type BrowserEventIngestReceipt = {
+    readonly accepted: number;
+};
+export declare const ingestBrowserEventBatch: (batch: BrowserEventBatch) => Effect.Effect<BrowserEventIngestReceipt, never, never>;
+export declare const ingestBrowserEvents: (input: unknown) => Effect.Effect<BrowserEventIngestReceipt, InvalidBrowserEventBatch>;
+export {};

package/dist/node/BrowserEventIngest.js

@@ -0,0 +1,38 @@
+import { Effect, Schema } from "effect";
+import { BrowserEventBatch } from "../BrowserEvents.js";
+import * as WideEvent from "../WideEvent.js";
+export class InvalidBrowserEventBatch extends Schema.TaggedError()("InvalidBrowserEventBatch", {
+    code: Schema.Literal("OBS_BROWSER_EVENTS_INVALID_BATCH"),
+    message: Schema.String,
+    cause: Schema.Defect(),
+}) {
+}
+const decodeBrowserEventBatch = Schema.decodeUnknownEffect(BrowserEventBatch);
+export const parseBrowserEventBatch = (input) => decodeBrowserEventBatch(input).pipe(Effect.mapError((cause) => new InvalidBrowserEventBatch({
+    code: "OBS_BROWSER_EVENTS_INVALID_BATCH",
+    message: "The browser event batch is invalid. Send a version 1 batch with bounded events and scalar fields.",
+    cause,
+})));
+const reservedFieldPrefixes = ["event.", "browser."];
+const trustedFields = (fields) => {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(fields)) {
+        if (reservedFieldPrefixes.some((prefix) => key.startsWith(prefix))) {
+            continue;
+        }
+        sanitized[key] = value;
+    }
+    return sanitized;
+};
+export const ingestBrowserEventBatch = Effect.fn("ingestBrowserEventBatch")(function* (batch) {
+    for (const event of batch.events) {
+        yield* WideEvent.emit(event.name, {
+            ...trustedFields(event.fields),
+            "event.source": "browser",
+            "browser.event.id": event.id,
+            "browser.event.occurred_at": event.occurredAt,
+        });
+    }
+    return { accepted: batch.events.length };
+});
+export const ingestBrowserEvents = (input) => parseBrowserEventBatch(input).pipe(Effect.flatMap(ingestBrowserEventBatch));

package/dist/node/Runtime.d.ts

@@ -0,0 +1,10 @@
+import { Effect, Runtime } from "effect";
+import type { Layer } from "effect";
+import type { EnvironmentVariables, InvalidTelemetryEnvironment } from "../TelemetryConfig.js";
+export declare const layer: (env?: EnvironmentVariables) => Layer.Layer<never, InvalidTelemetryEnvironment>;
+export type RunMainOptions = {
+    readonly env?: EnvironmentVariables;
+    readonly disableErrorReporting?: boolean;
+    readonly teardown?: Runtime.Teardown;
+};
+export declare const runMain: <A, E>(program: Effect.Effect<A, E>, options?: RunMainOptions) => void;

package/dist/node/Runtime.js

@@ -0,0 +1,25 @@
+import { Effect, Runtime } from "effect";
+import { layerFromEnv } from "../Telemetry.js";
+export const layer = (env) => layerFromEnv(env ?? process.env);
+const runProcessMain = Runtime.makeRunMain(({ fiber, teardown }) => {
+    let receivedSignal = false;
+    const onSignal = () => {
+        receivedSignal = true;
+        fiber.interruptUnsafe(fiber.id);
+    };
+    fiber.addObserver((exit) => {
+        process.removeListener("SIGINT", onSignal);
+        process.removeListener("SIGTERM", onSignal);
+        teardown(exit, (code) => {
+            if (receivedSignal || code !== 0) {
+                process.exit(code);
+            }
+        });
+    });
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+});
+export const runMain = (program, options) => runProcessMain(Effect.provide(program, layer(options?.env)), {
+    disableErrorReporting: options?.disableErrorReporting,
+    teardown: options?.teardown,
+});

package/dist/node/index.d.ts

@@ -0,0 +1,2 @@
+export { ingestBrowserEventBatch, ingestBrowserEvents, InvalidBrowserEventBatch, parseBrowserEventBatch, type BrowserEventIngestReceipt, } from "./BrowserEventIngest.js";
+export { layer, runMain, type RunMainOptions } from "./Runtime.js";

package/dist/node/index.js

@@ -0,0 +1,2 @@
+export { ingestBrowserEventBatch, ingestBrowserEvents, InvalidBrowserEventBatch, parseBrowserEventBatch, } from "./BrowserEventIngest.js";
+export { layer, runMain } from "./Runtime.js";

package/dist/testing/index.d.ts

@@ -0,0 +1,54 @@
+import { Effect, Layer, Option, type Exit } from "effect";
+import { TelemetryConfig } from "../TelemetryConfig.js";
+export type CapturedAttributeValue = string | number | boolean;
+export type CapturedAttributes = ReadonlyMap<string, CapturedAttributeValue>;
+export type CapturedSpan = {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly parentSpanId: Option.Option<string>;
+    readonly name: string;
+    readonly statusCode: number;
+    readonly statusMessage: Option.Option<string>;
+    readonly attributes: CapturedAttributes;
+    readonly resourceAttributes: CapturedAttributes;
+};
+export type CapturedLog = {
+    readonly traceId: Option.Option<string>;
+    readonly spanId: Option.Option<string>;
+    readonly severityText: Option.Option<string>;
+    readonly body: Option.Option<string>;
+    readonly attributes: CapturedAttributes;
+    readonly resourceAttributes: CapturedAttributes;
+};
+export type CapturedMetricPoint = {
+    readonly value: Option.Option<number>;
+    readonly attributes: CapturedAttributes;
+};
+export type CapturedMetric = {
+    readonly name: string;
+    readonly points: ReadonlyArray<CapturedMetricPoint>;
+    readonly resourceAttributes: CapturedAttributes;
+};
+export type CapturedTelemetry = {
+    readonly spans: ReadonlyArray<CapturedSpan>;
+    readonly logs: ReadonlyArray<CapturedLog>;
+    readonly metrics: ReadonlyArray<CapturedMetric>;
+};
+export type TelemetryRun<A, E> = {
+    readonly exit: Exit.Exit<A, E>;
+    readonly telemetry: CapturedTelemetry;
+};
+export declare const attribute: (attributes: CapturedAttributes, key: string) => Option.Option<CapturedAttributeValue>;
+export type CapturedRequest = {
+    readonly path: string;
+    readonly payload: unknown;
+};
+export type RunOptions = {
+    readonly config?: TelemetryConfig;
+};
+export type TelemetryCapture = {
+    readonly layer: Layer.Layer<never>;
+    readonly telemetry: Effect.Effect<CapturedTelemetry>;
+};
+export declare const makeCapture: (options?: RunOptions | undefined) => Effect.Effect<TelemetryCapture, never, never>;
+export declare const run: <A, E, R>(program: Effect.Effect<A, E, R>, options?: RunOptions) => Effect.Effect<TelemetryRun<A, E>, never, R>;

package/dist/testing/index.js

@@ -0,0 +1,184 @@
+import { Effect, Layer, Option, Ref, Schema } from "effect";
+import { HttpClient, HttpClientResponse } from "effect/unstable/http";
+import { layerOtlp } from "../Telemetry.js";
+import { TelemetryConfig } from "../TelemetryConfig.js";
+const AttributeValue = Schema.Struct({
+    stringValue: Schema.String.pipe(Schema.optionalKey),
+    boolValue: Schema.Boolean.pipe(Schema.optionalKey),
+    intValue: Schema.Union([Schema.String, Schema.Number]).pipe(Schema.optionalKey),
+    doubleValue: Schema.Number.pipe(Schema.optionalKey),
+});
+const Attribute = Schema.Struct({
+    key: Schema.String,
+    value: AttributeValue,
+});
+const Attributes = Schema.Array(Attribute).pipe(Schema.withDecodingDefault(Effect.succeed([])));
+const ExportedResource = Schema.Struct({
+    attributes: Attributes,
+});
+const ExportedSpan = Schema.Struct({
+    traceId: Schema.String,
+    spanId: Schema.String,
+    parentSpanId: Schema.String.pipe(Schema.optionalKey),
+    name: Schema.String,
+    status: Schema.Struct({
+        code: Schema.Number.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
+        message: Schema.String.pipe(Schema.optionalKey),
+    }).pipe(Schema.withDecodingDefault(Effect.succeed({ code: 0 }))),
+    attributes: Attributes,
+});
+const SpanExport = Schema.Struct({
+    resourceSpans: Schema.Array(Schema.Struct({
+        resource: ExportedResource,
+        scopeSpans: Schema.Array(Schema.Struct({ spans: Schema.Array(ExportedSpan) })),
+    })),
+});
+const ExportedLogRecord = Schema.Struct({
+    traceId: Schema.String.pipe(Schema.optionalKey),
+    spanId: Schema.String.pipe(Schema.optionalKey),
+    severityText: Schema.String.pipe(Schema.optionalKey),
+    body: Schema.Struct({ stringValue: Schema.String.pipe(Schema.optionalKey) }).pipe(Schema.optionalKey),
+    attributes: Attributes,
+});
+const LogExport = Schema.Struct({
+    resourceLogs: Schema.Array(Schema.Struct({
+        resource: ExportedResource,
+        scopeLogs: Schema.Array(Schema.Struct({ logRecords: Schema.Array(ExportedLogRecord) })),
+    })),
+});
+const MetricDataPoint = Schema.Struct({
+    attributes: Attributes,
+    asDouble: Schema.Number.pipe(Schema.optionalKey),
+    asInt: Schema.Union([Schema.String, Schema.Number]).pipe(Schema.optionalKey),
+});
+const DataPoints = Schema.Struct({ dataPoints: Schema.Array(MetricDataPoint) });
+const ExportedMetric = Schema.Struct({
+    name: Schema.String,
+    sum: DataPoints.pipe(Schema.optionalKey),
+    gauge: DataPoints.pipe(Schema.optionalKey),
+});
+const MetricExport = Schema.Struct({
+    resourceMetrics: Schema.Array(Schema.Struct({
+        resource: ExportedResource,
+        scopeMetrics: Schema.Array(Schema.Struct({ metrics: Schema.Array(ExportedMetric) })),
+    })),
+});
+const decodeSpanExport = Schema.decodeUnknownEffect(SpanExport);
+const decodeLogExport = Schema.decodeUnknownEffect(LogExport);
+const decodeMetricExport = Schema.decodeUnknownEffect(MetricExport);
+const toAttributes = (attributes) => {
+    const converted = new Map();
+    for (const attribute of attributes) {
+        const value = attribute.value;
+        if (value.stringValue !== undefined) {
+            converted.set(attribute.key, value.stringValue);
+        }
+        else if (value.boolValue !== undefined) {
+            converted.set(attribute.key, value.boolValue);
+        }
+        else if (value.intValue !== undefined) {
+            converted.set(attribute.key, Number(value.intValue));
+        }
+        else if (value.doubleValue !== undefined) {
+            converted.set(attribute.key, value.doubleValue);
+        }
+    }
+    return converted;
+};
+export const attribute = (attributes, key) => Option.fromNullishOr(attributes.get(key));
+const captureClient = (store) => HttpClient.make((request, url) => Effect.gen(function* () {
+    const body = request.body;
+    if (body._tag === "Uint8Array") {
+        const payload = yield* Effect.try(() => JSON.parse(new TextDecoder().decode(body.body))).pipe(Effect.option);
+        if (Option.isSome(payload)) {
+            yield* Ref.update(store, (requests) => [
+                ...requests,
+                { path: url.pathname, payload: payload.value },
+            ]);
+        }
+    }
+    return HttpClientResponse.fromWeb(request, new Response("{}", { status: 200 }));
+}));
+const decodeCapturedTelemetry = Effect.fn("decodeCapturedTelemetry")(function* (requests) {
+    const spans = [];
+    const logs = [];
+    const metrics = [];
+    for (const request of requests) {
+        if (request.path.endsWith("/v1/traces")) {
+            const spanExport = yield* decodeSpanExport(request.payload).pipe(Effect.orDie);
+            for (const resourceSpans of spanExport.resourceSpans) {
+                const resourceAttributes = toAttributes(resourceSpans.resource.attributes);
+                for (const scopeSpans of resourceSpans.scopeSpans) {
+                    for (const span of scopeSpans.spans) {
+                        spans.push({
+                            traceId: span.traceId,
+                            spanId: span.spanId,
+                            parentSpanId: Option.fromNullishOr(span.parentSpanId),
+                            name: span.name,
+                            statusCode: span.status.code,
+                            statusMessage: Option.fromNullishOr(span.status.message),
+                            attributes: toAttributes(span.attributes),
+                            resourceAttributes,
+                        });
+                    }
+                }
+            }
+        }
+        else if (request.path.endsWith("/v1/logs")) {
+            const logExport = yield* decodeLogExport(request.payload).pipe(Effect.orDie);
+            for (const resourceLogs of logExport.resourceLogs) {
+                const resourceAttributes = toAttributes(resourceLogs.resource.attributes);
+                for (const scopeLogs of resourceLogs.scopeLogs) {
+                    for (const log of scopeLogs.logRecords) {
+                        logs.push({
+                            traceId: Option.fromNullishOr(log.traceId),
+                            spanId: Option.fromNullishOr(log.spanId),
+                            severityText: Option.fromNullishOr(log.severityText),
+                            body: Option.fromNullishOr(log.body?.stringValue),
+                            attributes: toAttributes(log.attributes),
+                            resourceAttributes,
+                        });
+                    }
+                }
+            }
+        }
+        else if (request.path.endsWith("/v1/metrics")) {
+            const metricExport = yield* decodeMetricExport(request.payload).pipe(Effect.orDie);
+            for (const resourceMetrics of metricExport.resourceMetrics) {
+                const resourceAttributes = toAttributes(resourceMetrics.resource.attributes);
+                for (const scopeMetrics of resourceMetrics.scopeMetrics) {
+                    for (const metric of scopeMetrics.metrics) {
+                        const dataPoints = metric.sum?.dataPoints ?? metric.gauge?.dataPoints ?? [];
+                        metrics.push({
+                            name: metric.name,
+                            points: dataPoints.map((dataPoint) => ({
+                                value: Option.fromNullishOr(dataPoint.asDouble ?? dataPoint.asInt).pipe(Option.map(Number)),
+                                attributes: toAttributes(dataPoint.attributes),
+                            })),
+                            resourceAttributes,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return { spans, logs, metrics };
+});
+const defaultConfig = new TelemetryConfig({
+    serviceName: "telemetry-testing",
+    serviceVersion: "0.0.0",
+    environment: "test",
+    otlpEndpoint: new URL("http://telemetry.invalid"),
+});
+export const makeCapture = Effect.fn("makeCapture")(function* (options) {
+    const store = yield* Ref.make([]);
+    const layer = layerOtlp(options?.config ?? defaultConfig).pipe(Layer.provide(Layer.succeed(HttpClient.HttpClient, captureClient(store))));
+    const telemetry = Ref.get(store).pipe(Effect.flatMap(decodeCapturedTelemetry));
+    return { layer, telemetry };
+});
+export const run = (program, options) => Effect.gen(function* () {
+    const capture = yield* makeCapture(options);
+    const exit = yield* program.pipe(Effect.provide(capture.layer), Effect.exit);
+    const telemetry = yield* capture.telemetry;
+    return { exit, telemetry };
+});

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@equipe-tech/observability",
+  "version": "0.1.0",
+  "description": "Contrato OpenTelemetry da Equipe Tech: configuracao, layer OTLP e wide events sobre Effect",
+  "license": "Apache-2.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "import": "./dist/node/index.js"
+    },
+    "./nestjs": {
+      "types": "./dist/nestjs/index.d.ts",
+      "import": "./dist/nestjs/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser/index.d.ts",
+      "import": "./dist/browser/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun ../../scripts/build-packages.ts",
+    "prepack": "bun run build"
+  },
+  "dependencies": {
+    "effect": "4.0.0-rc.111"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.2.1",
+    "@nestjs/core": "^11.2.1",
+    "@nestjs/platform-express": "^11.2.1",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "rxjs": "^7.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@nestjs/common": {
+      "optional": true
+    },
+    "rxjs": {
+      "optional": true
+    }
+  }
+}