h1v3 0.6.4 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "h1v3",
-  "version": "0.6.4",
+  "version": "0.7.1",
   "description": "",
   "license": "MIT",
   "author": "",

package/src/configuration.js

@@ -3,7 +3,7 @@ import { all, assertNewDataDoesNotHave, assertNewDataHasString, any, assertNewDa
 
 export const RAW_STORE_META = Symbol("Raw database metadata");
 
-export function configureConfigStore(paths, _onValueWritten, _logger) {
+export function configureConfigStore(paths, _onValueWritten, _observe) {
 
     if (!paths?.config?.path) throw new Error("Missing: paths.config.path");
     return {
@@ -17,10 +17,12 @@ export function configureConfigStore(paths, _onValueWritten, _logger) {
 
 }
 
+const googleLogLevels = ["DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY"];
+
 function decideSeverity(newData) {
 
-    const text = newData.severity_text?.toLowerCase();
-    return ["trace", "fatal", "info", "debug", "error", "warn"].includes(text) ? text : "info";
+    const text = newData.severity_text?.toUpperCase();
+    return googleLogLevels.includes(text) ? text : "info";
 
 }
 
@@ -30,7 +32,7 @@ function decideMessage(newData) {
 
 }
 
-function handleLogValueWritten(logger, e) {
+function handleO11yEventWritten(observe, e) {
 
     const { after } = e.data;
     const newData = after.val();
@@ -39,7 +41,7 @@ function handleLogValueWritten(logger, e) {
         const now = new Date();
         const time_server_ms = now.valueOf();
         const timestamp = now.toISOString();
-        const payload = {
+        observe({
             "logging.googleapis.com/trace": `projects/${process.env.GCLOUD_PROJECT}/traces/${newData.trace_id}`,
             "logging.googleapis.com/spanId": newData.span_id,
             "message": decideMessage(newData),
@@ -49,31 +51,30 @@ function handleLogValueWritten(logger, e) {
                 time_server_ms
             },
             timestamp
-        };
+        });
         after.ref.update({ time_server_ms });
-        logger.write(payload);
 
     }
 
 }
 
-export function configureLoggingStore({ paths, onValueWritten, logger, region, instance }) {
+export function configureLoggingStore({ paths, onValueWritten, observe, region, instance }) {
 
     if (!paths) throw new Error("Missing paths");
     if (!onValueWritten) throw new Error("Missing onValueWritten");
-    if (!logger) throw new Error("Missing logger");
+    if (!observe) throw new Error("Missing observe");
     if (!region) throw new Error("Missing region");
     if (!instance) throw new Error("Missing instance");
 
-    const ref = paths?.logs?.path;
-    if (!ref) throw new Error("Missing: paths.logs.path");
+    const ref = paths?.o11y?.path;
+    if (!ref) throw new Error("Missing: paths.o11y.path");
     const triggerPath = refPathToTriggerPath(ref);
     return Object.assign(
         onValueWritten({
             ref: triggerPath,
             region,
             instance
-        }, handleLogValueWritten.bind(this, logger)),
+        }, handleO11yEventWritten.bind(this, observe)),
         {
             [RAW_STORE_META]: {
                 raw: true,
@@ -82,7 +83,7 @@ export function configureLoggingStore({ paths, onValueWritten, logger, region, i
                 write: all(
                     // required
                     assertNewDataHasString("body", 500, 1),
-                    assertNewDataHasOneOf("severity_text", "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"),
+                    assertNewDataHasOneOf("severity_text", ...googleLogLevels),
                     // trace context
                     all(
                         assertNewDataHasLowercaseHexCharacters("trace_id", 32),

package/src/event-store/configuration.js

@@ -4,10 +4,10 @@ import { refPathToTriggerPath } from "../paths.js";
 
 export const EVENT_STORE_META = Symbol("Event store configuration metadata");
 
-export function configureEventStore({ ref, projections, ...rest }, { onValueWritten, logger, region, instance }) {
+export function configureEventStore({ ref, projections, ...rest }, { onValueWritten, observe, region, instance }) {
 
     if (!onValueWritten) throw new Error("Missing onValueWritten");
-    if (!logger) throw new Error("Missing logger");
+    if (!observe) throw new Error("Missing observe");
     if (!region) throw new Error("Missing region");
     if (!instance) throw new Error("Missing instance");
 
@@ -18,7 +18,7 @@ export function configureEventStore({ ref, projections, ...rest }, { onValueWrit
     const writeRefPath = `${eventStorePath}/${EVENTS}/{eid}`;
 
     // handle an incoming write event
-    const handler = e => updateProjections(e.data.after, projections, logger, rest.debug);
+    const handler = e => updateProjections(e.data.after, projections, observe, rest.debug);
 
     const metadata = {
         ...rest,
@@ -35,10 +35,10 @@ export function configureEventStore({ ref, projections, ...rest }, { onValueWrit
 
 }
 
-configureEventStore.inject = ({ onValueWritten, logger, paths, region, instance }) =>
+configureEventStore.inject = ({ onValueWritten, observe, paths, region, instance }) =>
 
     (eventStoreFactory, ...args) =>
 
-            configureEventStore(eventStoreFactory(paths, ...args), { onValueWritten, logger, region, instance });
+            configureEventStore(eventStoreFactory(paths, ...args), { onValueWritten, observe, region, instance });
 
 

package/src/event-store/projections.js

@@ -1,7 +1,7 @@
 import { PROJECTIONS } from "../../dist/browser/client/event-store.js";
 import { inspect } from "node:util";
 
-export async function updateProjections(incomingEventSnap, projectionTransformationPerEvent, logger, debug = false) {
+export async function updateProjections(incomingEventSnap, projectionTransformationPerEvent, observe, debug = false) {
 
     // order the events
     const eventsSnap = await incomingEventSnap.ref.parent.get();
@@ -35,7 +35,11 @@ export async function updateProjections(incomingEventSnap, projectionTransformat
 
         return (agg, e) => {
 
-            logger.warn("Missing transform for event", { projection, event: e });
+            observe({
+                severity: "WARNING",
+                message: "Missing transform for event",
+                logData: { projection, event: e }
+            });
             return agg;
 
         };
@@ -46,9 +50,13 @@ export async function updateProjections(incomingEventSnap, projectionTransformat
 
         const projectionRef = incomingEventSnap.ref.parent.parent.child(PROJECTIONS).child(projection);
         const incomingEvent = incomingEventSnap.val();
-        logger.info("Writing projection after event", {
-            path: projectionRef,
-            incomingEvent
+        observe({
+            severity: "INFO",
+            message: "Writing projection after event",
+            logData: {
+                path: projectionRef,
+                incomingEvent
+            }
         });
         try {
 
@@ -58,7 +66,11 @@ export async function updateProjections(incomingEventSnap, projectionTransformat
 
             const data = inspect(view).replace(/\n */g, " ");
             const path = projectionRef.toString();
-            logger.error(`Error writing projection: ${err?.message}`, { projection, path, data });
+            observe({
+                severity: "ERROR",
+                message: `Error writing projection: ${err?.message}`,
+                logData: { projection, path, data }
+            });
 
         }
 

package/src/index.js

@@ -31,4 +31,6 @@ export function explodePathVars(expr) {
     if (typeof expr !== "string") return expr;
     return expr.replaceAll(/\/(\$[^/]*)/g, "/' + $1 + '");
 
-}
+}
+
+export * as o11y from "./observability/index.js";

package/src/observability/index.js

@@ -0,0 +1,123 @@
+export async function provider({ trace, projectId, serviceName, log }) {
+
+    if (!serviceName) throw new Error("Missing serviceName");
+    if (!trace) throw new Error("Missing trace");
+    if (!projectId) throw new Error("Missing projectId");
+    if (!log) throw new Error("Missing log");
+
+    return async ({
+        message, severity, // required
+        traceId, spanId, timestamp, // advised
+        logData, // optional log line
+        spanStart, spanEnd, spanAttributes // optional trace attributes
+    }) => {
+
+        if (!message) throw new Error("Missing message");
+        if (!severity) throw new Error("Missing severity");
+
+        traceId = traceId || console.warn("No trace id provided - one will be generated") || generateLowerHex(16);
+        spanId = spanId || console.warn("No span id provided - one will be generated") || generateLowerHex(8);
+        timestamp = timestamp || console.warn("No timestamp provided - one will be generated") || new Date().toISOString();
+        if (!spanStart) {
+
+            spanStart = spanEnd = new Date(timestamp);
+
+        }
+
+        const tracePath = `projects/${projectId}/traces/${traceId}`;
+        const projectTraceSpanName = `${tracePath}/spans/${spanId}`;
+
+        const startTime = asISOString(spanStart);
+        const endTime = asISOString(spanEnd);
+
+        await createSpan({ trace }, { serviceName, projectTraceSpanName, message, spanId, startTime, endTime, spanAttributes });
+        await writeLogLine({ log, projectId }, { tracePath, spanId, severity, timestamp, message, logData });
+
+    };
+
+}
+
+function generateLowerHex(byteLength) {
+
+    const bytes = crypto.getRandomValues(new Uint8Array(byteLength));
+    return Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+
+}
+
+export function toTraceAttributes(obj) {
+
+    const attributeMap = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === null || value === undefined) continue;
+
+        switch (typeof value) {
+            case 'string':
+                attributeMap[key] = { stringValue: { value } };
+                break;
+            case 'number':
+                // Cloud Trace expects integers as strings
+                attributeMap[key] = { intValue: String(Math.trunc(value)) };
+                break;
+            case 'boolean':
+                attributeMap[key] = { boolValue: value };
+                break;
+            default:
+                // fallback to JSON string
+                attributeMap[key] = { stringValue: { value: JSON.stringify(value) } };
+                break;
+        }
+    }
+    return { attributeMap };
+
+}
+
+async function writeLogLine({ log, projectId }, { message, tracePath, spanId, severity, timestamp, logData }) {
+
+    const logMeta = {
+        resource: { type: "global", labels: { "project_id": projectId } },
+        trace: tracePath,
+        spanId,
+        severity,
+        traceSampled: "true",
+        timestamp
+    };
+    console.log("Log meta", logMeta);
+
+    const entry = log.entry(
+        logMeta,
+        {
+            message,
+            ...logData
+        }
+    );
+    await log.write(entry);
+
+}
+
+async function createSpan({ trace }, { serviceName, projectTraceSpanName, spanId, startTime, endTime, spanAttributes, message }) {
+
+    const attributes = toTraceAttributes({
+        "service.name": serviceName,
+        message,
+        ...spanAttributes
+    });
+    await trace.projects.traces.spans.createSpan({
+        name: projectTraceSpanName,
+        requestBody: {
+            attributes,
+            name: projectTraceSpanName,
+            spanId,
+            displayName: { value: serviceName },
+            startTime,
+            endTime
+        }
+    });
+
+}
+
+function asISOString(x) {
+
+    if (typeof x === "string") return x;
+    if (typeof x?.toISOString !== "function") throw new Error("Missing toISOString function");
+    return x.toISOString();
+}