h1v3 0.7.3 → 0.7.4

package/dist/browser/client/context.js

@@ -26,7 +26,8 @@ export async function inject({ database, authentication, metaURL, handleError =
     if (!metaURL) throw new Error("Missing metaURL");
     if (!authentication) throw new Error("Missing authentication");
 
-    const meta = await fetch(metaURL).then(resp => resp.json())
+    // const meta = await fetch(metaURL).then(resp => resp.json())
+    const { default: meta } = await import(metaURL, { with: { type: "json" } });
 
     const log = logger(database, authentication, meta.o11y.path);
     const teamMembershipStoreFactory = ({ tid }) => eventStore(database, authentication, populateParameters({ tid }, meta.team.membership.path));

package/dist/browser/client/id.js

@@ -23,7 +23,7 @@ function rand62(n) {
 
 }
 
-export const timeId = () => `${Date.now()}-${rand62(21)}`;
+export const timeId = suffix => `${Date.now()}-${suffix || rand62(21)}`;
 
 export const generateSpanId = () => generateLowerHex(8);
 

package/dist/browser/client/logger.js

@@ -14,25 +14,35 @@ function munge(attributes) {
 export function logger(database, authentication, path, defaultAttributes) {
 
     const { db, ref, set } = database;
+    const { auth } = authentication;
 
-    async function recordLog(trace_id, level, sharedAttributes, { body, parent_id, attributes }) {
-
-        const span_id = generateSpanId();
-        console.log(defaultAttributes, sharedAttributes, attributes);
-        const data = {
-            meta: { uid: authentication.auth.currentUser.uid },
-            body,
-            trace_id,
-            span_id,
-            severity_text: level,
-            time_client_ms: Date.now(),
-            attributes: munge({ ...defaultAttributes, ...sharedAttributes, ...attributes })
-        };
-        if (parent_id) data.parent_id = parent_id;
-        const refPath = path.replace("$id", timeId());
-        console.log("Logging", data, "to", refPath);
-        return await set(ref(db, refPath), data);
+    async function recordLog(traceId, level, sharedAttributes, { message, parentSpanId, spanId, attributes }) {
 
+        let data;
+        try {
+
+            const uid = auth?.currentUser?.uid;
+            if (!uid) throw new Error("No current user id. Is the user logged in?");
+
+            spanId = spanId || generateSpanId();
+            data = {
+                meta: { uid },
+                message,
+                traceId,
+                spanId,
+                severity_text: level,
+                time_client_ms: Date.now(),
+                attributes: munge({ ...defaultAttributes, ...sharedAttributes, ...attributes })
+            };
+            if (parentSpanId) data.parentSpanId = parentSpanId;
+            const refPath = path.replace("$id", `${traceId}-${spanId}`);
+            return await set(ref(db, refPath), data);
+
+        } catch(err) {
+
+            console.error("Error dispatching o11y message", data, err);
+
+        }
 
     }
 
@@ -41,17 +51,13 @@ export function logger(database, authentication, path, defaultAttributes) {
         context(sharedAttributes) {
 
             const id = generateTraceId();
-            return {
-                id,
-                trace: recordLog.bind(this, id, "TRACE", sharedAttributes),
-                debug: recordLog.bind(this, id, "DEBUG", sharedAttributes),
-                info: recordLog.bind(this, id, "INFO", sharedAttributes),
-                warn: recordLog.bind(this, id, "WARN", sharedAttributes),
-                error: recordLog.bind(this, id, "ERROR", sharedAttributes),
-                fatal: recordLog.bind(this, id, "FATAL", sharedAttributes)
-            };
+            const ret = { id };
+            for(const x of ["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"])
+                ret[x] = recordLog.bind(this, id, x.toUpperCase(), sharedAttributes);
+            return ret;
 
         }
+
     };
 
 }

package/package.json

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

package/src/configuration/configure-o11y-store.js

@@ -11,12 +11,15 @@ function decideSeverity(newData) {
     return googleLogLevels.includes(text) ? text : "INFO";
 
 }
+const DISPATCHED = "DISPATCHED";
+const BLOCKED = "BLOCKED";
+
 /*
 
     message, severity, // required
     traceId, spanId, timestamp, // advised
     logData, // optional log line
-    spanStart, spanEnd, spanAttributes // optional trace attributes
+    spanStart, spanEnd, spanAttributes, parentSpanId // optional trace attributes
 
 */
 function handleO11yEventWritten(observe, e) {
@@ -26,24 +29,66 @@ function handleO11yEventWritten(observe, e) {
     if (!newData.time_server_ms) {
 
         const now = new Date();
-        const time_server_ms = now.valueOf();
         const timestamp = now.toISOString();
-        const message = newData?.message || "Missing log message";
+        const time_server_ms = now.valueOf();
+        const { traceId, spanId, parentSpanId, ...rest } = newData;
+
+        const { id } = e.params;
+        const [id_traceId, id_spanId] = id.split("-");
+        let action;
+        if (traceId !== id_traceId || spanId !== id_spanId) {
+
+            action = blockEvent({ message: "Mismatched event id", timestamp, details: { id, traceId, spanId }});
+
+        } else if (!newData?.meta?.uid) {
+
+            action = blockEvent({ message: "Missing / invalid uid", timestamp, details: { uid: newData?.meta?.uid } });
+
+        } else {
+
+            action = dispatch({ rest, time_server_ms, traceId, spanId, parentSpanId, timestamp });
+
+        }
+
+        after.ref.update({
+            time_server_ms,
+            timestamp,
+            action
+        });
+
+    }
 
-        const { traceId, spanId, ...rest } = newData;
-        const logData = { ...rest, time_server_ms };
 
+    function dispatch({ rest, time_server_ms, traceId, spanId, parentSpanId, timestamp }) {
+
+        const message = newData?.message || "Missing log message";
+        const uid = newData.meta?.uid;
+        const logData = { ...rest, time_server_ms };
         observe({
             message,
             severity: decideSeverity(newData),
 
-            traceId: newData.trace_id,
-            spanId: newData.span_id,
+            traceId,
+            spanId,
+            parentSpanId,
             timestamp,
 
-            logData
+            logData,
+            spanAttributes: { "user.id": uid }
+        });
+        return DISPATCHED;
+
+    }
+
+    function blockEvent({ message, timestamp, details }) {
+
+        observe({
+            message: `O11y event blocked: ${message}`,
+            severity: "CRITICAL",
+            timestamp,
+            logData: { ...details, newData }
         });
-        after.ref.update({ time_server_ms });
+        return BLOCKED;
 
     }
 
@@ -73,29 +118,30 @@ export function configureO11yStore({ paths, onValueWritten, observe, region, ins
                 read: false,
                 write: all(
                     // required
-                    assertNewDataHasString("body", 500, 1),
+                    assertNewDataHasString("message", 500, 1),
                     assertNewDataHasOneOf("severity_text", ...googleLogLevels),
                     // trace context
                     all(
-                        assertNewDataHasLowercaseHexCharacters("trace_id", 32),
-                        assertNewDataFieldDoesNotMatch("trace_id", "0*")
+                        assertNewDataHasLowercaseHexCharacters("traceId", 32),
+                        assertNewDataFieldDoesNotMatch("traceId", "0*")
                     ),
                     all(
-                        assertNewDataHasLowercaseHexCharacters("span_id", 16),
-                        assertNewDataFieldDoesNotMatch("span_id", "0*")
+                        assertNewDataHasLowercaseHexCharacters("spanId", 16),
+                        assertNewDataFieldDoesNotMatch("spanId", "0*")
                     ),
-                    // forbid server time faking
+                    // forbid server time and action faking
                     assertNewDataDoesNotHave("time_server_ms"),
+                    assertNewDataDoesNotHave("action"),
                     // optional bits
                     any(
                         assertNewDataDoesNotHave("time_client_ms"),
                         assertNewDataHasNumber("time_client_ms")
                     ),
                     any(
-                        assertNewDataDoesNotHave("parent_id"),
+                        assertNewDataDoesNotHave("parentSpanId"),
                         all(
-                            assertNewDataHasLowercaseHexCharacters("parent_id", 16),
-                            assertNewDataFieldDoesNotMatch("parent_id", "0*")
+                            assertNewDataHasLowercaseHexCharacters("parentSpanId", 16),
+                            assertNewDataFieldDoesNotMatch("parentSpanId", "0*")
                         )
                     )
                 )

package/src/observability/index.js

@@ -9,7 +9,7 @@ export function provider({ trace, projectId, serviceName, log }) {
         message, severity, // required
         traceId, spanId, timestamp, // advised
         logData, // optional log line
-        spanStart, spanEnd, spanAttributes // optional trace attributes
+        spanStart, spanEnd, spanAttributes, parentSpanId // optional trace attributes
     }) => {
 
         if (!message) throw new Error("Missing message");
@@ -30,7 +30,7 @@ export function provider({ trace, projectId, serviceName, log }) {
         const startTime = asISOString(spanStart);
         const endTime = asISOString(spanEnd);
 
-        await createSpan({ trace }, { serviceName, projectTraceSpanName, message, spanId, startTime, endTime, spanAttributes });
+        await createSpan({ trace }, { parentSpanId, serviceName, projectTraceSpanName, message, spanId, startTime, endTime, spanAttributes });
         await writeLogLine({ log, projectId }, { tracePath, spanId, severity, timestamp, message, logData });
 
     };
@@ -92,23 +92,25 @@ async function writeLogLine({ log, projectId }, { message, tracePath, spanId, se
 
 }
 
-async function createSpan({ trace }, { serviceName, projectTraceSpanName, spanId, startTime, endTime, spanAttributes, message }) {
+async function createSpan({ trace }, { serviceName, projectTraceSpanName, spanId, parentSpanId, startTime, endTime, spanAttributes, message }) {
 
     const attributes = toTraceAttributes({
         "service.name": serviceName,
         message,
         ...spanAttributes
     });
+    const requestBody = {
+        attributes,
+        name: projectTraceSpanName,
+        spanId,
+        displayName: { value: serviceName },
+        startTime,
+        endTime
+    };
+    if (parentSpanId) requestBody.parentSpanId = parentSpanId;
     await trace.projects.traces.spans.createSpan({
         name: projectTraceSpanName,
-        requestBody: {
-            attributes,
-            name: projectTraceSpanName,
-            spanId,
-            displayName: { value: serviceName },
-            startTime,
-            endTime
-        }
+        requestBody
     });
 
 }

package/src/system/main.js

@@ -1,5 +1,5 @@
 import minimist from "minimist";
-import { loadConfiguration } from "../load-configuration.js";
+import { loadConfiguration } from "../configuration/load-configuration.js"
 
 export async function main(commands) {