chore: remove log noise

Author: coodos

infrastructure/evault-core/src/core/db/db.service.ts

@@ -44,15 +44,11 @@ export class DbService {
     private async runQueryInternal(query: string, params: Record<string, any>) {
         const firstLine = query.trim().split("\n")[0].slice(0, 80);
         return timed(`db.query "${firstLine}"`, async () => {
-            const session = await timed("db.session.open", async () =>
-                this.driver.session(),
-            );
+            const session = this.driver.session();
             try {
-                return await timed("db.session.run", () =>
-                    session.run(query, params),
-                );
+                return await session.run(query, params);
             } finally {
-                await timed("db.session.close", () => session.close());
+                await session.close();
             }
         });
     }

infrastructure/evault-core/src/core/protocol/vault-access-guard.ts

@@ -3,7 +3,7 @@ import type { YogaInitialContext } from "graphql-yoga";
 import * as jose from "jose";
 import type { DbService } from "../db/db.service";
 import type { MetaEnvelope } from "../db/types";
-import { newTraceId, timed } from "../utils/timing";
+import { timed } from "../utils/timing";
 
 export type VaultContext = YogaInitialContext & {
     currentUser: string | null;
@@ -64,14 +64,9 @@ export class VaultAccessGuard {
                     expiresAt: now + JWKS_TTL_MS,
                 };
                 jwksCache.set(jwksUrl, cached);
-            } else {
-                console.log("[timing] guard.validateToken.jwksCacheHit");
             }
 
-            const { payload } = await timed(
-                "guard.validateToken.jwtVerify",
-                () => jose.jwtVerify(token, cached!.jwks),
-            );
+            const { payload } = await jose.jwtVerify(token, cached.jwks);
 
             return payload;
         } catch (error) {
@@ -252,13 +247,6 @@ export class VaultAccessGuard {
         ) => Promise<any>,
     ) {
         return async (parent: T, args: Args, context: VaultContext) => {
-            const traceId = newTraceId("op");
-            const opKind = args.id
-                ? "id-targeted"
-                : args.envelopeId
-                  ? "envelope-targeted"
-                  : "bulk";
-            console.log(`[timing] ${traceId} guard.middleware.begin ${opKind}`);
             // Check if this is storeMetaEnvelope operation (has input with ontology, payload, acl)
             const isStoreOperation =
                 args.input &&
@@ -269,20 +257,14 @@ export class VaultAccessGuard {
                 !args.id; // storeMetaEnvelope doesn't have id, updateMetaEnvelopeById does
 
             // CRITICAL: Validate authentication BEFORE executing any resolver
-            await timed(
-                "guard.validateAuthentication",
-                () => this.validateAuthentication(context, isStoreOperation),
-                traceId,
+            await timed("guard.validateAuthentication", () =>
+                this.validateAuthentication(context, isStoreOperation),
             );
 
             // For operations that don't require a specific meta envelope ID (bulk queries)
             if (!args.id && !args.envelopeId) {
                 // Authentication validated, now execute resolver
-                const result = await timed(
-                    "guard.resolver(bulk)",
-                    () => resolver(parent, args, context),
-                    traceId,
-                );
+                const result = await resolver(parent, args, context);
 
                 // If the result is an array
                 if (Array.isArray(result)) {
@@ -307,29 +289,19 @@ export class VaultAccessGuard {
             const metaEnvelopeId = args.id || args.envelopeId;
             if (!metaEnvelopeId) {
                 // Authentication validated, now execute resolver
-                const result = await timed(
-                    "guard.resolver(no-id)",
-                    () => resolver(parent, args, context),
-                    traceId,
-                );
+                const result = await resolver(parent, args, context);
                 return this.filterACL(result);
             }
 
             // Check if envelope exists and user has access
-            const { hasAccess, exists } = await timed(
-                "guard.checkAccess",
-                () => this.checkAccess(metaEnvelopeId, context),
-                traceId,
+            const { hasAccess, exists } = await timed("guard.checkAccess", () =>
+                this.checkAccess(metaEnvelopeId, context),
             );
 
             // For update operations with input, allow in-place creation if envelope doesn't exist
             if (!exists && args.input) {
                 // Envelope doesn't exist for this eName - allow in-place creation
-                const result = await timed(
-                    "guard.resolver(in-place-create)",
-                    () => resolver(parent, args, context),
-                    traceId,
-                );
+                const result = await resolver(parent, args, context);
                 return this.filterACL(result);
             }
 
@@ -343,11 +315,7 @@ export class VaultAccessGuard {
             }
 
             // Execute resolver and filter ACL
-            const result = await timed(
-                "guard.resolver(targeted)",
-                () => resolver(parent, args, context),
-                traceId,
-            );
+            const result = await resolver(parent, args, context);
 
             // If result is null (envelope not found), return null
             if (result === null) {

infrastructure/evault-core/src/core/utils/timing.ts

@@ -1,5 +1,8 @@
 const ENABLED = process.env.EVAULT_TIMING !== "0";
-const SLOW_MS = Number(process.env.EVAULT_TIMING_SLOW_MS) || 0;
+const SLOW_MS =
+    process.env.EVAULT_TIMING_SLOW_MS !== undefined
+        ? Number(process.env.EVAULT_TIMING_SLOW_MS)
+        : 50;
 
 let counter = 0;
 export function newTraceId(prefix = "t"): string {