@shivaedev/platform 0.13.0 → 0.14.1

package/src/server/safeOtlpSerialization.ts

@@ -1,50 +1,63 @@
-import { Layer } from "effect";
-import { HttpBody } from "effect/http";
+import { Effect, Layer } from "effect";
 import type { OtlpResource } from "effect/observability";
 import { OtlpSerialization } from "effect/observability";
+import { redactOtlpUrl } from "#redactOtlpUrl.ts";
 import { isSensitiveKey, REDACTED, redactText } from "#rpc-server/sensitive.ts";
 
 function sensitive(key: string) {
 	return isSensitiveKey(key) || ["db.user", "db.user.name", "db.connection_string"].includes(key.toLowerCase());
 }
-function text(value: string) {
-	return redactText(value, sensitive).replaceAll(/(?<scheme>\b[a-z][a-z0-9+.-]*:\/\/)[^/@\s]+@/giu, `$<scheme>${REDACTED}@`);
+export function redactOtlpText(value: string, key = "") {
+	return redactText(redactOtlpUrl(value, key), sensitive);
 }
-function attributeValue(value: OtlpResource.AnyValue): OtlpResource.AnyValue {
+function attributeValue(value: OtlpResource.AnyValue, key: string): OtlpResource.AnyValue {
 	return {
 		...value,
-		...(typeof value.stringValue === "string" ? { stringValue: text(value.stringValue) } : {}),
-		...(value.arrayValue ? { arrayValue: { values: value.arrayValue.values.map(attributeValue) } } : {}),
+		...(typeof value.stringValue === "string" ? { stringValue: redactOtlpText(value.stringValue, key) } : {}),
+		...(value.arrayValue ? { arrayValue: { values: value.arrayValue.values.map((item) => attributeValue(item, key)) } } : {}),
 		...(value.kvlistValue ? { kvlistValue: { values: attributes(value.kvlistValue.values) } } : {}),
 	};
 }
 function attributes(values: OtlpResource.KeyValue[]): OtlpResource.KeyValue[] {
 	return values.map(({ key, value }) => ({
 		key,
-		value: sensitive(key) ? { stringValue: REDACTED } : attributeValue(value),
+		value: sensitive(key) ? { stringValue: REDACTED } : attributeValue(value, key),
 	}));
 }
 
-export const safeOtlpSerialization = Layer.succeed(OtlpSerialization.OtlpSerialization, {
-	logs: HttpBody.jsonUnsafe,
-	metrics: HttpBody.jsonUnsafe,
-	traces: (data) =>
-		HttpBody.jsonUnsafe({
-			...data,
-			resourceSpans: data.resourceSpans.map((resource) => ({
-				...resource,
-				resource: { ...resource.resource, attributes: attributes(resource.resource.attributes) },
-				scopeSpans: resource.scopeSpans.map((scope) => ({
-					...scope,
-					spans: scope.spans.map((span) => ({
-						...span,
-						attributes: attributes(span.attributes),
-						events: span.events.map((event) => ({ ...event, attributes: attributes(event.attributes), name: text(event.name) })),
-						links: span.links.map((link) => ({ ...link, attributes: attributes(link.attributes) })),
-						name: text(span.name),
-						status: { ...span.status, ...(span.status.message === undefined ? {} : { message: text(span.status.message) }) },
+function spanName(span: { readonly name: string; readonly kind: number; readonly attributes: OtlpResource.KeyValue[] }) {
+	if (span.kind === 2) {
+		const method = span.attributes.find(({ key }) => key === "http.request.method")?.value.stringValue;
+		const route = span.attributes.find(({ key }) => key === "http.route")?.value.stringValue;
+		if (typeof method === "string") {
+			return typeof route === "string" ? `${method} ${route}` : method;
+		}
+	}
+	return span.name;
+}
+
+export const safeOtlpSerialization = Layer.effect(
+	OtlpSerialization.OtlpSerialization,
+	Effect.map(OtlpSerialization.OtlpSerialization, (serialization) => ({
+		...serialization,
+		traces: (data) =>
+			serialization.traces({
+				...data,
+				resourceSpans: data.resourceSpans.map((resource) => ({
+					...resource,
+					resource: { ...resource.resource, attributes: attributes(resource.resource.attributes) },
+					scopeSpans: resource.scopeSpans.map((scope) => ({
+						...scope,
+						spans: scope.spans.map((span) => ({
+							...span,
+							attributes: attributes(span.attributes),
+							events: span.events.map((event) => ({ ...event, attributes: attributes(event.attributes), name: redactOtlpText(event.name) })),
+							links: span.links.map((link) => ({ ...link, attributes: attributes(link.attributes) })),
+							name: redactOtlpText(spanName(span)),
+							status: { ...span.status, ...(span.status.message === undefined ? {} : { message: redactOtlpText(span.status.message) }) },
+						})),
 					})),
 				})),
-			})),
-		}),
-});
+			}),
+	})),
+);