h1v3 0.7.2 → 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.2",
+  "version": "0.7.4",
   "description": "",
   "license": "MIT",
   "author": "",

package/src/client/node.js

@@ -1,4 +1,4 @@
-import { EVENT_STORE_META } from "../event-store/configuration.js";
+import { EVENT_STORE_META } from "../configuration/configure-eventStore.js";
 import { eventStore as eventStoreModular } from "../../dist/browser/client/event-store.js";
 
 function adaptDatabase(db) {

package/src/{event-store/configuration.js → configuration/configure-eventStore.js}

@@ -1,6 +1,7 @@
 import { EVENTS } from "../../dist/browser/client/event-store.js";
-import { updateProjections } from "./projections.js";
-import { refPathToTriggerPath } from "../paths.js";
+import { refPathToTriggerPath } from "./paths.js";
+import { updateProjections } from "../event-store/projections.js";
+
 
 export const EVENT_STORE_META = Symbol("Event store configuration metadata");
 
@@ -34,11 +35,4 @@ export function configureEventStore({ ref, projections, ...rest }, { onValueWrit
     );
 
 }
-
-configureEventStore.inject = ({ onValueWritten, observe, paths, region, instance }) =>
-
-    (eventStoreFactory, ...args) =>
-
-            configureEventStore(eventStoreFactory(paths, ...args), { onValueWritten, observe, region, instance });
-
-
+configureEventStore.inject = ({ onValueWritten, observe, paths, region, instance }) => (eventStoreFactory, ...args) => configureEventStore(eventStoreFactory(paths, ...args), { onValueWritten, observe, region, instance });

package/src/configuration/configure-metadata-endpoint.js

@@ -0,0 +1,48 @@
+import { loadConfigurationFromModule } from "./load-configuration.js";
+
+function buildConfigDigest(module, paths) {
+
+
+    const refConfigMap = loadConfigurationFromModule(module)
+        .flatMap(x => x.map(y => y[1]))
+        .reduce((index, config) => ({ ...index, [config.ref]: config }), {});
+
+    function patchForPath(map) {
+
+        const ret = {
+            ...map
+        };
+        const mappedConfig = refConfigMap[map.path];
+        for (const [x, y] of Object.entries(ret).filter(([_, v]) => typeof v === "object")) {
+
+            ret[x] = patchForPath(y);
+
+        }
+        if (mappedConfig && (mappedConfig.read || mappedConfig.write)) {
+
+            ret.projections = mappedConfig.projections;
+            ret.eventTypes = mappedConfig.eventTypes;
+
+        }
+        return ret;
+
+    }
+
+    return patchForPath(paths);
+
+}
+const publicFor1Day = "public, max-age=86400";
+
+export function configureMetadataEndpoint({ module, paths, onRequest, region, cacheControl = publicFor1Day }) {
+
+    const digest = buildConfigDigest(module, paths);
+    return onRequest(
+        { region },
+        async (_, res) => {
+
+            res.header("Cache-Control", cacheControl).send(digest);
+
+        }
+    );
+
+}

package/src/{configuration.js → configuration/configure-o11y-store.js}

@@ -1,72 +1,8 @@
-import { loadConfigurationFromModule } from "./load-configuration.js";
 import { refPathToTriggerPath } from "./paths.js";
-import { all, assertNewDataDoesNotHave, assertNewDataHasString, any, assertNewDataHasNumber, assertNewDataHasOneOf, assertNewDataHasLowercaseHexCharacters, assertNewDataFieldDoesNotMatch } from "./rules.js";
+import { all, assertNewDataHasString, assertNewDataHasOneOf, assertNewDataHasLowercaseHexCharacters, assertNewDataFieldDoesNotMatch, assertNewDataDoesNotHave, any, assertNewDataHasNumber } from "./rules.js";
 
-export const RAW_STORE_META = Symbol("Raw database metadata");
-
-export function configureConfigStore(paths, _onValueWritten, _observe) {
-
-    if (!paths?.config?.path) throw new Error("Missing: paths.config.path");
-    return {
-        [RAW_STORE_META]: {
-            raw: true,
-            ref: paths.config.path,
-            read: true,
-            write: false
-        }
-    };
-
-}
-
-function buildConfigDigest(module, paths) {
-
-
-    const refConfigMap =
-        loadConfigurationFromModule(module)
-        .flatMap(x => x.map(y => y[1]))
-        .reduce((index, config) => ({ ...index, [config.ref]: config }), {});
-
-    function patchForPath(map) {
-
-        const ret = {
-            ...map
-        };
-        const mappedConfig = refConfigMap[map.path];
-        for (const [x, y] of Object.entries(ret).filter(([_, v]) => typeof v === "object")) {
-
-            ret[x] = patchForPath(y);
-
-        }
-        if (mappedConfig && (mappedConfig.read || mappedConfig.write)) {
-
-            ret.projections = mappedConfig.projections;
-            ret.eventTypes = mappedConfig.eventTypes;
-
-        }
-        return ret;
-
-    }
-
-    return patchForPath(paths);
-
-}
-
-const publicFor1Day = "public, max-age=86400";
-
-export function configureMetadataEndpoint({ module, paths, onRequest, region, cacheControl = publicFor1Day }) {
-
-    const digest = buildConfigDigest(module, paths);
-    return onRequest(
-        { region },
-        async (_, res) => {
-
-            res.header("Cache-Control", cacheControl).send(digest);
-
-        }
-    );
-
-}
 
+export const RAW_STORE_META = Symbol("Raw database metadata");
 const googleLogLevels = ["DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY"];
 
 function decideSeverity(newData) {
@@ -75,13 +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) {
@@ -91,31 +29,72 @@ 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 { traceId, spanId, ...rest } = newData
-        const logData = { ...rest, time_server_ms };
+        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
+        });
+
+    }
+
+
+    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;
 
     }
 
 }
 
-export function configureLoggingStore({ paths, onValueWritten, observe, region, instance }) {
+export function configureO11yStore({ paths, onValueWritten, observe, region, instance }) {
 
     if (!paths) throw new Error("Missing paths");
     if (!onValueWritten) throw new Error("Missing onValueWritten");
@@ -139,29 +118,30 @@ export function configureLoggingStore({ paths, onValueWritten, observe, region,
                 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*")
                         )
                     )
                 )
@@ -170,4 +150,3 @@ export function configureLoggingStore({ paths, onValueWritten, observe, region,
     );
 
 }
-

package/src/{load-configuration.js → configuration/load-configuration.js}

@@ -1,7 +1,7 @@
 import { resolve } from "path";
 import { pathToFileURL } from "url";
-import { EVENT_STORE_META } from "./event-store/configuration.js";
-import { RAW_STORE_META } from "./configuration.js";
+import { EVENT_STORE_META } from "./configure-eventStore.js";
+import { RAW_STORE_META } from "./configure-o11y-store.js";
 
 export async function loadConfiguration(argv) {
 

package/src/{rules.js → configuration/rules.js}

@@ -1,4 +1,4 @@
-import { PROJECTIONS } from "../dist/browser/client/event-store.js";
+import { PROJECTIONS } from "../../dist/browser/client/event-store.js";
 
 export const any = (...args) =>
 

package/src/exec-eventstore.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { listEventStores } from "./commands/list-event-stores.js";
 import { generateRules } from "./commands/generate-rules.js";

package/src/index.js

@@ -1,8 +1,8 @@
 export { PROJECTIONS, EVENTS } from "../dist/browser/client/event-store.js";
 
-export * from "./event-store/configuration.js";
-
-export * from "./configuration.js";
+export * from "./configuration/configure-eventStore.js";
+export * from "./configuration/configure-metadata-endpoint.js";
+export * from "./configuration/configure-o11y-store.js";
 
 export const passThroughView = {
     "?": (view, e, key) => {
@@ -24,7 +24,7 @@ export * as userTeams from "./membership/user-teams/store.js";
 
 export * as userInvites from "./membership/userInvites/store.js";
 
-export * as rules from "./rules.js";
+export * as rules from "./configuration/rules.js";
 
 export function explodePathVars(expr) {
 
@@ -34,5 +34,3 @@ export function explodePathVars(expr) {
 }
 
 export * as o11y from "./observability/index.js";
-
-export { loadConfigurationFromModule } from "./load-configuration.js";

package/src/membership/team-details/store.js

@@ -1,4 +1,4 @@
-import { assertIsMyTeam } from "../../rules.js";
+import { assertIsMyTeam } from "../../configuration/rules.js";
 import { eventTypes } from "./events.js";
 import current from "./projections/current.js";
 import { verifyStorePaths } from "./verify-store-paths.js";

package/src/membership/team-membership/store.js

@@ -13,7 +13,7 @@ import {
     any,
     all,
     assertEventIsOfType
-} from "../../rules.js";
+} from "../../configuration/rules.js";
 import { verifyStorePaths } from "../team-details/verify-store-paths.js";
 
 export function store(paths) {

package/src/membership/user-profile/store.js

@@ -1,4 +1,4 @@
-import { assertUserIsMe } from "../../rules.js";
+import { assertUserIsMe } from "../../configuration/rules.js";
 import { verifyStorePaths } from "../team-details/verify-store-paths.js";
 import { eventTypes } from "./events.js";
 import current from "./projections/current.js";

package/src/membership/user-teams/store.js

@@ -1,4 +1,4 @@
-import { assertUserIsMe } from "../../rules.js";
+import { assertUserIsMe } from "../../configuration/rules.js";
 import { verifyStorePaths } from "../team-details/verify-store-paths.js";
 import { eventTypes } from "./events.js";
 import current from "./projections/current.js";

package/src/membership/userInvites/store.js

@@ -2,7 +2,7 @@ import { eventTypes, ACCEPTED_INVITATION, REJECTED_INVITATION } from "./events.j
 import pending from "./projections/pending.js";
 import { PROJECTIONS } from "../../index.js";
 import { verifyStorePaths } from "../team-details/verify-store-paths.js";
-import { all, any, assertEventIsOfType, assertDataFieldIsMyVerifiedEmail, assertMyVerifiedEmail, not, assertNewDataHas } from "../../rules.js";
+import { all, any, assertEventIsOfType, assertDataFieldIsMyVerifiedEmail, assertMyVerifiedEmail, not, assertNewDataHas } from "../../configuration/rules.js";
 
 const assertAcceptedOrRejectedEvent = assertEventIsOfType(
     ACCEPTED_INVITATION,

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) {