@equipe-tech/observability 0.2.1 → 0.3.5

package/dist/PolicyOtlpLogger.d.ts

@@ -0,0 +1,18 @@
+import { Duration, Effect, Layer, Logger } from "effect";
+import type * as LogLevel from "effect/LogLevel";
+import type { HttpClient } from "effect/unstable/http";
+import { OtlpExporter, OtlpSerialization } from "effect/unstable/observability";
+export declare const logLevelSeverityNumber: (level: LogLevel.LogLevel) => number;
+export type PolicyOtlpLoggerOptions = {
+    readonly url: string;
+    readonly resource?: {
+        readonly serviceName?: string | undefined;
+        readonly serviceVersion?: string | undefined;
+        readonly attributes?: {
+            readonly [key: string]: string;
+        } | undefined;
+    } | undefined;
+    readonly shutdownTimeout?: Duration.Input | undefined;
+};
+export declare const makePolicyOtlpLogger: (options: PolicyOtlpLoggerOptions) => Effect.Effect<Logger.Logger<unknown, void>, never, OtlpExporter.Flusher | HttpClient.HttpClient | OtlpSerialization.OtlpSerialization | import("effect/Scope").Scope>;
+export declare const layerPolicyOtlpLogger: (options: PolicyOtlpLoggerOptions) => Layer.Layer<OtlpExporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization>;

package/dist/PolicyOtlpLogger.js

@@ -0,0 +1,142 @@
+import { Array as Arr, Cause, Clock, Duration, Effect, Layer, Logger, Option, Predicate, References, Schema, } from "effect";
+import { OtlpExporter, OtlpResource, OtlpSerialization } from "effect/unstable/observability";
+import { CurrentDataPolicy } from "./policy/DataPolicy.js";
+import { sanitizeText, transformSignalFields } from "./policy/PolicyTransform.js";
+import { effectDroppedAttributesKey } from "./policy/PolicyVocabulary.js";
+const Scalar = Schema.Union([
+    Schema.String,
+    Schema.Number.check(Schema.isFinite()),
+    Schema.Boolean,
+]);
+const decodeScalar = Schema.decodeUnknownOption(Scalar);
+export const logLevelSeverityNumber = (level) => {
+    switch (level) {
+        case "Trace":
+            return 1;
+        case "Debug":
+            return 5;
+        case "Info":
+            return 9;
+        case "Warn":
+            return 13;
+        case "Error":
+            return 17;
+        case "Fatal":
+            return 21;
+        case "All":
+        case "None":
+            return 0;
+    }
+};
+export const makePolicyOtlpLogger = Effect.fn("makePolicyOtlpLogger")(function* (options) {
+    const serialization = yield* OtlpSerialization.OtlpSerialization;
+    const resource = yield* OtlpResource.fromConfig(options.resource);
+    const clock = yield* Clock.Clock;
+    const existingLoggers = yield* Logger.CurrentLoggers;
+    const exporter = yield* OtlpExporter.make({
+        label: "PolicyOtlpLogger",
+        url: options.url,
+        headers: undefined,
+        maxBatchSize: 1000,
+        exportInterval: Duration.seconds(1),
+        body: (records) => [
+            serialization.logs({
+                resourceLogs: [
+                    {
+                        resource,
+                        scopeLogs: [
+                            {
+                                scope: { name: OtlpResource.serviceNameUnsafe(resource) },
+                                logRecords: records,
+                            },
+                        ],
+                    },
+                ],
+            }),
+            Effect.void,
+        ],
+        shutdownTimeout: options.shutdownTimeout ?? Duration.seconds(3),
+    });
+    return Logger.make((entry) => {
+        const policy = entry.fiber.getRef(CurrentDataPolicy);
+        const raw = {};
+        let unsupportedDropped = 0;
+        for (const [key, value] of Object.entries(entry.fiber.getRef(References.CurrentLogAnnotations))) {
+            const decoded = decodeScalar(value);
+            if (key === effectDroppedAttributesKey && Option.isSome(decoded)) {
+                if (Predicate.isNumber(decoded.value))
+                    unsupportedDropped += decoded.value;
+                continue;
+            }
+            if (Option.isSome(decoded)) {
+                raw[key] = decoded.value;
+            }
+            else {
+                unsupportedDropped += 1;
+            }
+        }
+        const packageGeneratedKeys = new Set();
+        raw["effect.fiber.id"] = entry.fiber.id;
+        packageGeneratedKeys.add("effect.fiber.id");
+        const nowMillis = entry.date.getTime();
+        for (const [label, startTime] of entry.fiber.getRef(References.CurrentLogSpans)) {
+            const key = `effect.log_span.${label}`;
+            raw[key] = `${nowMillis - startTime}ms`;
+            packageGeneratedKeys.add(key);
+        }
+        const sanitizedCause = entry.cause.reasons.length > 0
+            ? sanitizeText(policy, Cause.pretty(entry.cause), "log")
+            : undefined;
+        if (sanitizedCause !== undefined) {
+            raw["log.error"] = sanitizedCause;
+            packageGeneratedKeys.add("log.error");
+        }
+        const decision = transformSignalFields(policy, "log", raw);
+        const delegatedAnnotations = Object.fromEntries(Object.entries(decision.value).filter(([key]) => !packageGeneratedKeys.has(key)));
+        const droppedPackageGenerated = [...packageGeneratedKeys].filter((key) => decision.value[key] === undefined).length;
+        const delegatedDropped = decision.dropped - droppedPackageGenerated + unsupportedDropped;
+        const now = clock.currentTimeNanosUnsafe().toString();
+        const attributes = OtlpResource.entriesToAttributes(Object.entries(decision.value));
+        const messages = Arr.ensure(entry.message).map((message) => {
+            const decoded = decodeScalar(message);
+            if (Option.isSome(decoded)) {
+                return Predicate.isString(decoded.value)
+                    ? sanitizeText(policy, decoded.value, "log")
+                    : decoded.value;
+            }
+            return "[REDACTED]";
+        });
+        const sanitizedFiber = Object.create(entry.fiber);
+        Object.defineProperty(sanitizedFiber, "getRef", {
+            value: (reference) => reference === References.CurrentLogAnnotations
+                ? {
+                    ...delegatedAnnotations,
+                    [effectDroppedAttributesKey]: delegatedDropped,
+                }
+                : entry.fiber.getRef(reference),
+        });
+        const sanitizedEntry = {
+            ...entry,
+            message: messages,
+            fiber: sanitizedFiber,
+            cause: sanitizedCause === undefined ? Cause.empty : Cause.fail(sanitizedCause),
+        };
+        for (const logger of existingLoggers)
+            logger.log(sanitizedEntry);
+        const record = {
+            severityNumber: logLevelSeverityNumber(entry.logLevel),
+            severityText: entry.logLevel,
+            timeUnixNano: now,
+            observedTimeUnixNano: now,
+            attributes,
+            body: OtlpResource.unknownToAttributeValue(messages.length === 1 ? messages[0] : messages),
+            droppedAttributesCount: decision.dropped + unsupportedDropped,
+        };
+        if (entry.fiber.currentSpan) {
+            record.traceId = entry.fiber.currentSpan.traceId;
+            record.spanId = entry.fiber.currentSpan.spanId;
+        }
+        exporter.push(record);
+    });
+});
+export const layerPolicyOtlpLogger = (options) => Logger.layer([makePolicyOtlpLogger(options)], { mergeWithExisting: false }).pipe(Layer.provideMerge(OtlpExporter.layerFlusher));

package/dist/RedactionPolicy.d.ts

@@ -1,9 +1,2 @@
-import { type BrowserEventFields } from "./BrowserEvents.js";
-import type { WideEventFields } from "./WideEvent.js";
-export declare const sensitiveFieldReplacement = "****";
-export declare const sensitiveTextReplacement = "[REDACTED]";
-export declare const collectorBlockedKeyPattern: string;
-export declare const collectorBlockedValuePatterns: string[];
-export declare const isSensitiveFieldKey: (key: string) => boolean;
-export declare const sanitizeBrowserFields: (fields: WideEventFields) => BrowserEventFields;
-export declare const sanitizeBrowserEventName: (name: string) => string;
+export { sanitizeBrowserFields, sanitizeEventName } from "./policy/BrowserFieldPolicy.js";
+export { baseBlockedKeys, collectorBlockedKeyPattern, collectorBlockedValuePatterns, isSensitiveFieldKey, sensitiveFieldReplacement, sensitiveTextReplacement, } from "./policy/PolicyVocabulary.js";

package/dist/RedactionPolicy.js

@@ -1,246 +1,2 @@
-import { Option, Predicate, Schema } from "effect";
-import { maxEventNameLength, maxFieldKeyLength, maxFieldsPerEvent, maxFieldValueLength, } from "./BrowserEvents.js";
-export const sensitiveFieldReplacement = "****";
-export const sensitiveTextReplacement = "[REDACTED]";
-const sensitiveTermSources = [
-    "authorization",
-    "proxy[._-]?authorization",
-    "cookie",
-    "set[._-]?cookie",
-    "password",
-    "passwd",
-    "secret",
-    "token",
-    "api[._-]?key",
-    "apikey",
-    "access[._-]?key",
-    "client[._-]?secret",
-    "private[._-]?key",
-    "email",
-    "phone",
-    "cpf",
-    "cnpj",
-    "document",
-];
-export const collectorBlockedKeyPattern = `(?i:${sensitiveTermSources.join("|")})(?:[._-]|[A-Z0-9]|$)`;
-export const collectorBlockedValuePatterns = [
-    "(?i)Bearer[[:space:]]+[A-Za-z0-9._~+/=-]+",
-    "(?:sk|rk)[_-][A-Za-z0-9_*.-]{3,}",
-    "eyJ[A-Za-z0-9_-]+[.]eyJ[A-Za-z0-9_-]+[.][A-Za-z0-9_-]+",
-    "(?i)[A-Z0-9._%+-]+@[A-Z0-9.-]+[.][A-Z]{2,}",
-    "(?s)-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----.*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----",
-];
-const maxOriginalFieldKeyLength = 2_048;
-const maxOriginalStringLength = 16_384;
-const maxJsonDepth = 32;
-const maxJsonValues = 1_024;
-const SensitiveScalar = Schema.Union([
-    Schema.String,
-    Schema.Number.check(Schema.isFinite()),
-    Schema.Boolean,
-]);
-const decodeSensitiveScalar = Schema.decodeUnknownOption(SensitiveScalar);
-const decodeJsonText = Schema.decodeOption(Schema.fromJsonString(Schema.Json));
-const decodeJsonObject = Schema.decodeUnknownOption(Schema.JsonObject);
-const asciiCaseInsensitive = (source) => source.replace(/[A-Za-z]/g, (letter) => `[${letter.toLowerCase()}${letter.toUpperCase()}]`);
-const sensitiveTerms = sensitiveTermSources.map(asciiCaseInsensitive).join("|");
-const sensitiveKeyPattern = new RegExp(`(?:${sensitiveTerms})(?=[._-]|[A-Z0-9]|$)`);
-const sensitiveTextTermPattern = new RegExp(`(?:${sensitiveTerms})(?=[._-]|[A-Z0-9]|[^A-Za-z0-9._-]|$)`);
-const coreValuePatterns = [
-    /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
-    /(?:sk|rk)[_-][A-Za-z0-9_*.-]{3,}/g,
-    /eyJ[A-Za-z0-9_-]+[.]eyJ[A-Za-z0-9_-]+[.][A-Za-z0-9_-]+/g,
-    /[A-Z0-9._%+-]+@[A-Z0-9.-]+[.][A-Z]{2,}/gi,
-    /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g,
-];
-const structuredAssignmentPattern = /([A-Za-z0-9_.-]+)(\s*[=:]\s*)(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^,;\s]+))/g;
-export const isSensitiveFieldKey = (key) => sensitiveKeyPattern.test(key);
-const replaceCoreValues = (value) => {
-    let sanitized = value;
-    for (const pattern of coreValuePatterns) {
-        pattern.lastIndex = 0;
-        sanitized = sanitized.replace(pattern, sensitiveTextReplacement);
-    }
-    return sanitized;
-};
-const containsCoreValue = (value) => {
-    for (const pattern of coreValuePatterns) {
-        pattern.lastIndex = 0;
-        if (pattern.test(value)) {
-            pattern.lastIndex = 0;
-            return true;
-        }
-    }
-    return false;
-};
-const replaceStructuredAssignments = (value) => {
-    structuredAssignmentPattern.lastIndex = 0;
-    let sanitized = "";
-    let offset = 0;
-    for (const match of value.matchAll(structuredAssignmentPattern)) {
-        const index = match.index;
-        const full = match[0];
-        const key = match[1];
-        const separator = match[2];
-        if (!Predicate.isNumber(index) || !Predicate.isString(full) || !Predicate.isString(key)) {
-            continue;
-        }
-        sanitized += value.slice(offset, index);
-        if (!isSensitiveFieldKey(key) || !Predicate.isString(separator)) {
-            sanitized += full;
-            offset = index + full.length;
-            continue;
-        }
-        if (Predicate.isString(match[3])) {
-            sanitized += `${key}${separator}"${sensitiveTextReplacement}"`;
-        }
-        else if (Predicate.isString(match[4])) {
-            sanitized += `${key}${separator}'${sensitiveTextReplacement}'`;
-        }
-        else {
-            sanitized += `${key}${separator}${sensitiveTextReplacement}`;
-        }
-        offset = index + full.length;
-    }
-    return sanitized + value.slice(offset);
-};
-const containsStructuredAssignment = (value) => replaceStructuredAssignments(value) !== value;
-const sanitizeJson = (source) => {
-    const root = { value: null };
-    const stack = [
-        {
-            source,
-            depth: 0,
-            sensitive: false,
-            assign: (value) => {
-                root.value = value;
-            },
-        },
-    ];
-    let visited = 0;
-    while (stack.length > 0) {
-        const current = stack.pop();
-        if (!Predicate.isNotUndefined(current)) {
-            continue;
-        }
-        visited += 1;
-        if (visited > maxJsonValues || current.depth > maxJsonDepth) {
-            return Option.none();
-        }
-        if (current.sensitive) {
-            current.assign(sensitiveTextReplacement);
-            continue;
-        }
-        if (current.source === null ||
-            Predicate.isNumber(current.source) ||
-            Predicate.isBoolean(current.source)) {
-            current.assign(current.source);
-            continue;
-        }
-        if (Predicate.isString(current.source)) {
-            current.assign(replaceCoreValues(replaceStructuredAssignments(current.source)));
-            continue;
-        }
-        if (Array.isArray(current.source)) {
-            const output = current.source.map(() => null);
-            current.assign(output);
-            for (let index = current.source.length - 1; index >= 0; index -= 1) {
-                const child = current.source[index];
-                if (!Predicate.isNotUndefined(child)) {
-                    continue;
-                }
-                stack.push({
-                    source: child,
-                    depth: current.depth + 1,
-                    sensitive: false,
-                    assign: (value) => {
-                        output[index] = value;
-                    },
-                });
-            }
-            continue;
-        }
-        const sourceObject = decodeJsonObject(current.source);
-        if (Option.isNone(sourceObject)) {
-            return Option.none();
-        }
-        const output = Object.create(null);
-        const outputKeys = new Set();
-        current.assign(output);
-        const keys = Object.keys(sourceObject.value);
-        for (const key of keys) {
-            if (key.length > maxOriginalFieldKeyLength ||
-                containsCoreValue(key) ||
-                containsStructuredAssignment(key)) {
-                continue;
-            }
-            output[key] = null;
-            outputKeys.add(key);
-        }
-        for (let index = keys.length - 1; index >= 0; index -= 1) {
-            const key = keys[index];
-            if (!Predicate.isString(key) || !outputKeys.has(key)) {
-                continue;
-            }
-            const child = sourceObject.value[key];
-            if (!Predicate.isNotUndefined(child)) {
-                continue;
-            }
-            stack.push({
-                source: child,
-                depth: current.depth + 1,
-                sensitive: isSensitiveFieldKey(key),
-                assign: (value) => {
-                    output[key] = value;
-                },
-            });
-        }
-    }
-    return Option.some(JSON.stringify(root.value));
-};
-const sanitizeString = (value, outputLimit) => {
-    if (value.length > maxOriginalStringLength) {
-        return sensitiveTextReplacement;
-    }
-    const trimmed = value.trimStart();
-    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-        const parsed = decodeJsonText(value);
-        if (Option.isSome(parsed)) {
-            const sanitizedJson = Option.getOrElse(sanitizeJson(parsed.value), () => sensitiveTextReplacement);
-            return sanitizedJson.length <= outputLimit ? sanitizedJson : sensitiveTextReplacement;
-        }
-        if (sensitiveTextTermPattern.test(value)) {
-            return sensitiveTextReplacement;
-        }
-    }
-    return replaceCoreValues(replaceStructuredAssignments(value));
-};
-const shouldDropKey = (key) => key.length > maxOriginalFieldKeyLength ||
-    containsCoreValue(key) ||
-    containsStructuredAssignment(key);
-export const sanitizeBrowserFields = (fields) => {
-    const sanitized = [];
-    const boundedKeys = new Set();
-    for (const [key, runtimeValue] of Object.entries(fields)) {
-        const decoded = decodeSensitiveScalar(runtimeValue);
-        if (Option.isNone(decoded) || key === "" || shouldDropKey(key)) {
-            continue;
-        }
-        const boundedKey = key.slice(0, maxFieldKeyLength);
-        if (boundedKeys.has(boundedKey)) {
-            continue;
-        }
-        const value = isSensitiveFieldKey(key)
-            ? sensitiveFieldReplacement
-            : Predicate.isString(decoded.value)
-                ? sanitizeString(decoded.value, maxFieldValueLength).slice(0, maxFieldValueLength)
-                : decoded.value;
-        sanitized.push([boundedKey, value]);
-        boundedKeys.add(boundedKey);
-        if (boundedKeys.size >= maxFieldsPerEvent) {
-            break;
-        }
-    }
-    return Object.fromEntries(sanitized);
-};
-export const sanitizeBrowserEventName = (name) => sanitizeString(name, maxEventNameLength).slice(0, maxEventNameLength);
+export { sanitizeBrowserFields, sanitizeEventName } from "./policy/BrowserFieldPolicy.js";
+export { baseBlockedKeys, collectorBlockedKeyPattern, collectorBlockedValuePatterns, isSensitiveFieldKey, sensitiveFieldReplacement, sensitiveTextReplacement, } from "./policy/PolicyVocabulary.js";

package/dist/ResourceIdentity.d.ts

@@ -0,0 +1,47 @@
+import { Effect, Option, Schema } from "effect";
+export declare const serviceNamespace = "equipe-tech";
+export declare const resourceNamePattern: RegExp;
+export declare const serviceNameMaxLength = 63;
+export declare const environmentNameMaxLength = 32;
+export declare const ServiceName: Schema.brand<Schema.String, "ServiceName">;
+export type ServiceName = typeof ServiceName.Type;
+export declare const EnvironmentName: Schema.brand<Schema.String, "EnvironmentName">;
+export type EnvironmentName = typeof EnvironmentName.Type;
+export declare const ServiceVersion: Schema.brand<Schema.String, "ServiceVersion">;
+export type ServiceVersion = typeof ServiceVersion.Type;
+export declare const ServiceInstanceId: Schema.brand<Schema.NonEmptyString, "ServiceInstanceId">;
+export type ServiceInstanceId = typeof ServiceInstanceId.Type;
+export declare const EnvironmentAliasPolicy: Schema.Literals<readonly ["emitted", "omitted"]>;
+export type EnvironmentAliasPolicy = typeof EnvironmentAliasPolicy.Type;
+declare const ResourceIdentity_base: Schema.Class<ResourceIdentity, Schema.Struct<{
+    serviceName: Schema.brand<Schema.String, "ServiceName">;
+    serviceVersion: Schema.brand<Schema.String, "ServiceVersion">;
+    environment: Schema.brand<Schema.String, "EnvironmentName">;
+    instance: Schema.withConstructorDefault<Schema.Option<Schema.brand<Schema.NonEmptyString, "ServiceInstanceId">>>;
+}>, {}>;
+export declare class ResourceIdentity extends ResourceIdentity_base {
+}
+export declare const ResourceIdentityField: Schema.Literals<readonly ["service.name", "service.version", "deployment.environment.name", "service.instance.id"]>;
+export type ResourceIdentityField = typeof ResourceIdentityField.Type;
+declare const InvalidResourceIdentity_base: Schema.Class<InvalidResourceIdentity, Schema.TaggedStruct<"InvalidResourceIdentity", {
+    readonly code: Schema.Literal<"OBS_RESOURCE_IDENTITY_INVALID">;
+    readonly message: Schema.String;
+    readonly field: Schema.Literals<readonly ["service.name", "service.version", "deployment.environment.name", "service.instance.id"]>;
+    readonly value: Schema.String;
+    readonly rule: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidResourceIdentity extends InvalidResourceIdentity_base {
+}
+export interface ResourceIdentityInput {
+    readonly serviceName: string;
+    readonly serviceVersion: string;
+    readonly environment: string;
+    readonly instance?: Option.Option<string> | undefined;
+}
+export declare const parseResourceIdentity: (input: ResourceIdentityInput) => Effect.Effect<ResourceIdentity, InvalidResourceIdentity, never>;
+export type ResourceAttributes = {
+    readonly [attributeName: string]: string;
+};
+export declare const instanceResourceAttributes: (identity: ResourceIdentity, alias: EnvironmentAliasPolicy) => ResourceAttributes;
+export declare const serviceResourceAttributes: (identity: ResourceIdentity, alias: EnvironmentAliasPolicy) => ResourceAttributes;
+export {};

package/dist/ResourceIdentity.js

@@ -0,0 +1,82 @@
+import { Effect, Option, Schema } from "effect";
+export const serviceNamespace = "equipe-tech";
+export const resourceNamePattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export const serviceNameMaxLength = 63;
+export const environmentNameMaxLength = 32;
+const semverPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+const immutableReleasePattern = /^[0-9a-f]{7,64}$/;
+export const ServiceName = Schema.String.check(Schema.isPattern(resourceNamePattern), Schema.isMaxLength(serviceNameMaxLength)).pipe(Schema.brand("ServiceName"));
+export const EnvironmentName = Schema.String.check(Schema.isPattern(resourceNamePattern), Schema.isMaxLength(environmentNameMaxLength)).pipe(Schema.brand("EnvironmentName"));
+export const ServiceVersion = Schema.String.check(Schema.makeFilter((value) => semverPattern.test(value) || immutableReleasePattern.test(value), {
+    expected: "SemVer 2.0.0 or a 7 to 64 character lowercase hexadecimal release identifier",
+})).pipe(Schema.brand("ServiceVersion"));
+export const ServiceInstanceId = Schema.NonEmptyString.check(Schema.isMaxLength(128)).pipe(Schema.brand("ServiceInstanceId"));
+export const EnvironmentAliasPolicy = Schema.Literals(["emitted", "omitted"]);
+const identityFields = {
+    serviceName: ServiceName,
+    serviceVersion: ServiceVersion,
+    environment: EnvironmentName,
+    instance: Schema.Option(ServiceInstanceId).pipe(Schema.withConstructorDefault(Effect.succeed(Option.none()))),
+};
+export class ResourceIdentity extends Schema.Class("@equipe-tech/observability/ResourceIdentity")(identityFields) {
+}
+export const ResourceIdentityField = Schema.Literals([
+    "service.name",
+    "service.version",
+    "deployment.environment.name",
+    "service.instance.id",
+]);
+export class InvalidResourceIdentity extends Schema.TaggedError()("InvalidResourceIdentity", {
+    code: Schema.Literal("OBS_RESOURCE_IDENTITY_INVALID"),
+    message: Schema.String,
+    field: ResourceIdentityField,
+    value: Schema.String,
+    rule: Schema.String,
+}) {
+}
+const serviceNameRule = "lowercase letters, numbers, and hyphens with at most 63 characters";
+const environmentNameRule = "lowercase letters, numbers, and hyphens with at most 32 characters";
+const serviceVersionRule = "SemVer 2.0.0 or a 7 to 64 character lowercase hexadecimal immutable release identifier";
+const serviceInstanceRule = "a non-empty value with at most 128 characters";
+const invalidIdentity = (field, value, rule, label) => new InvalidResourceIdentity({
+    code: "OBS_RESOURCE_IDENTITY_INVALID",
+    field,
+    value,
+    rule,
+    message: `${label} ${JSON.stringify(value)} is invalid. Use ${rule}.`,
+});
+const decodeServiceName = Schema.decodeUnknownEffect(ServiceName);
+const decodeServiceVersion = Schema.decodeUnknownEffect(ServiceVersion);
+const decodeEnvironmentName = Schema.decodeUnknownEffect(EnvironmentName);
+const decodeServiceInstanceId = Schema.decodeUnknownEffect(ServiceInstanceId);
+export const parseResourceIdentity = Effect.fn("parseResourceIdentity")(function* (input) {
+    const serviceName = yield* decodeServiceName(input.serviceName).pipe(Effect.mapError(() => invalidIdentity("service.name", input.serviceName, serviceNameRule, "Service name")));
+    const serviceVersion = yield* decodeServiceVersion(input.serviceVersion).pipe(Effect.mapError(() => invalidIdentity("service.version", input.serviceVersion, serviceVersionRule, "Service version")));
+    const environment = yield* decodeEnvironmentName(input.environment).pipe(Effect.mapError(() => invalidIdentity("deployment.environment.name", input.environment, environmentNameRule, "Environment name")));
+    const rawInstance = input.instance ?? Option.none();
+    const instance = yield* Option.match(rawInstance, {
+        onNone: () => Effect.succeed(Option.none()),
+        onSome: (value) => decodeServiceInstanceId(value).pipe(Effect.map(Option.some), Effect.mapError(() => invalidIdentity("service.instance.id", value, serviceInstanceRule, "Service instance ID"))),
+    });
+    return new ResourceIdentity({ serviceName, serviceVersion, environment, instance });
+});
+const projectedAttributes = (identity, alias) => {
+    const attributes = {
+        "service.namespace": serviceNamespace,
+        "service.name": identity.serviceName,
+        "service.version": identity.serviceVersion,
+        "deployment.environment.name": identity.environment,
+    };
+    if (alias === "emitted") {
+        attributes["deployment.environment"] = identity.environment;
+    }
+    return attributes;
+};
+export const instanceResourceAttributes = (identity, alias) => {
+    const attributes = projectedAttributes(identity, alias);
+    if (Option.isSome(identity.instance)) {
+        attributes["service.instance.id"] = identity.instance.value;
+    }
+    return attributes;
+};
+export const serviceResourceAttributes = (identity, alias) => projectedAttributes(identity, alias);

package/dist/Telemetry.d.ts

@@ -1,11 +1,26 @@
 import { Duration, Layer } from "effect";
 import { type HttpClient } from "effect/unstable/http";
 import { OtlpExporter } from "effect/unstable/observability";
+import type { InvalidResourceIdentity } from "./ResourceIdentity.js";
+import type { DuplicateReleaseVariable } from "./profile/ObservabilityConfigError.js";
 import type { EnvironmentVariables, InvalidTelemetryEnvironment } from "./TelemetryConfig.js";
 import { type TelemetryConfig } from "./TelemetryConfig.js";
+import { LayerMetricsRuntime } from "./MetricsRuntime.js";
+import { type DataPolicy } from "./policy/DataPolicy.js";
+import type { InvalidDataPolicy } from "./policy/DataPolicyError.js";
+import type { ContractRegistry } from "./profile/ObservabilityAdapter.js";
+import { type ResourceAttribute } from "./policy/ResourceAttributePolicy.js";
 export type OtlpLayerOptions = {
     readonly shutdownTimeout?: Duration.Input | undefined;
+    readonly policy?: DataPolicy | undefined;
+    readonly resourceAttributes?: ReadonlyArray<ResourceAttribute> | undefined;
+    readonly contract?: ContractRegistry | undefined;
 };
-export declare const layerOtlp: (config: TelemetryConfig, options?: OtlpLayerOptions) => Layer.Layer<OtlpExporter.Flusher, never, HttpClient.HttpClient>;
-export declare const layer: (config: TelemetryConfig, options?: OtlpLayerOptions) => Layer.Layer<OtlpExporter.Flusher>;
-export declare const layerFromEnv: (env: EnvironmentVariables, options?: OtlpLayerOptions) => Layer.Layer<OtlpExporter.Flusher, InvalidTelemetryEnvironment>;
+export declare const layerOtlp: (config: TelemetryConfig, options?: OtlpLayerOptions) => Layer.Layer<OtlpExporter.Flusher | LayerMetricsRuntime, InvalidDataPolicy, HttpClient.HttpClient>;
+type OtlpLayerOptionsWithoutResourceAttributes = Omit<OtlpLayerOptions, "resourceAttributes"> & {
+    readonly resourceAttributes?: undefined;
+};
+export declare function layer(config: TelemetryConfig, options?: OtlpLayerOptionsWithoutResourceAttributes): Layer.Layer<OtlpExporter.Flusher | LayerMetricsRuntime, never>;
+export declare function layer(config: TelemetryConfig, options: OtlpLayerOptions): Layer.Layer<OtlpExporter.Flusher | LayerMetricsRuntime, InvalidDataPolicy>;
+export declare const layerFromEnv: (env: EnvironmentVariables, options?: OtlpLayerOptions) => Layer.Layer<OtlpExporter.Flusher | LayerMetricsRuntime, InvalidTelemetryEnvironment | InvalidResourceIdentity | DuplicateReleaseVariable | InvalidDataPolicy>;
+export {};

package/dist/Telemetry.js

@@ -1,31 +1,49 @@
-import { Duration, Effect, Layer } from "effect";
+import { ConfigProvider, Duration, Effect, Layer } from "effect";
 import { FetchHttpClient, HttpClientRequest } from "effect/unstable/http";
-import { OtlpLogger, OtlpSerialization } from "effect/unstable/observability";
+import { OtlpSerialization } from "effect/unstable/observability";
+import { layerPolicyOtlpLogger } from "./PolicyOtlpLogger.js";
+import { instanceResourceAttributes } from "./ResourceIdentity.js";
 import { telemetryConfigFromEnv } from "./TelemetryConfig.js";
 import { layerMetricsRuntime } from "./MetricsRuntime.js";
-import { layerHttpServerOtlpTracer } from "./nestjs/HttpServerOtlpTracer.js";
+import { layerBrowserSignalExporter, layerHttpServerOtlpTracer, } from "./trace/HttpServerOtlpTracer.js";
+import { baseDataPolicy, CurrentDataPolicy } from "./policy/DataPolicy.js";
+import { layerBrowserMetricRecorder } from "./browser/BrowserMetricRecorder.js";
+import { parseResourceAttributes, } from "./policy/ResourceAttributePolicy.js";
+const packageResourceConfig = ConfigProvider.layer(ConfigProvider.fromUnknown({}));
 export const layerOtlp = (config, options = {}) => {
-    const base = HttpClientRequest.get(config.otlpEndpoint.toString());
-    const url = (path) => HttpClientRequest.appendUrl(base, path).url;
-    const resource = {
-        serviceName: config.serviceName,
-        serviceVersion: config.serviceVersion,
-        attributes: {
-            "deployment.environment.name": config.environment,
-        },
-    };
-    const metrics = layerMetricsRuntime(config, {
-        shutdownTimeoutMilliseconds: Duration.toMillis(options.shutdownTimeout ?? "3 seconds"),
-    });
-    return Layer.mergeAll(OtlpLogger.layer({
-        url: url("/v1/logs"),
-        resource,
-        shutdownTimeout: options.shutdownTimeout,
-    }), metrics, layerHttpServerOtlpTracer({
-        url: url("/v1/traces"),
-        resource,
-        shutdownTimeout: options.shutdownTimeout,
-    })).pipe(Layer.provide(OtlpSerialization.layerJson));
+    const policy = options.policy ?? baseDataPolicy;
+    const canonical = instanceResourceAttributes(config.identity, config.environmentAlias);
+    return Layer.unwrap(Effect.map(parseResourceAttributes(policy, canonical, options.resourceAttributes ?? []), (parsed) => {
+        const base = HttpClientRequest.get(config.otlpEndpoint.toString());
+        const url = (path) => HttpClientRequest.appendUrl(base, path).url;
+        const resource = {
+            serviceName: config.identity.serviceName,
+            serviceVersion: config.identity.serviceVersion,
+            attributes: Object.fromEntries(parsed),
+        };
+        const metrics = layerMetricsRuntime(config, {
+            shutdownTimeoutMilliseconds: Duration.toMillis(options.shutdownTimeout ?? "3 seconds"),
+            policy,
+            resourceAttributes: parsed,
+        });
+        return Layer.mergeAll(Layer.succeed(CurrentDataPolicy, policy), layerPolicyOtlpLogger({
+            url: url("/v1/logs"),
+            resource,
+            shutdownTimeout: options.shutdownTimeout,
+        }), layerBrowserMetricRecorder(options.contract).pipe(Layer.provideMerge(metrics)), layerHttpServerOtlpTracer({
+            url: url("/v1/traces"),
+            policy,
+            resource,
+            shutdownTimeout: options.shutdownTimeout,
+        }), layerBrowserSignalExporter({
+            tracesUrl: url("/v1/traces"),
+            policy,
+            resource,
+            shutdownTimeout: options.shutdownTimeout,
+        })).pipe(Layer.provide(OtlpSerialization.layerJson), Layer.provide(packageResourceConfig));
+    }));
 };
-export const layer = (config, options = {}) => layerOtlp(config, options).pipe(Layer.provide(FetchHttpClient.layer));
+export function layer(config, options = {}) {
+    return layerOtlp(config, options).pipe(Layer.provide(FetchHttpClient.layer));
+}
 export const layerFromEnv = (env, options = {}) => Layer.unwrap(Effect.map(telemetryConfigFromEnv(env), (config) => layer(config, options)));