@adventurelabs/scout-core 1.0.63 → 1.0.65

package/dist/helpers/herds.js

@@ -3,7 +3,12 @@ import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
 import { HerdModule, } from "../types/herd_module";
 export async function get_herds(client) {
+    const queryStartTime = Date.now();
+    console.log(`[get_herds] Starting database query at ${new Date(queryStartTime).toISOString()}`);
     const { data: herds } = await client.from("herds").select();
+    const queryEndTime = Date.now();
+    const queryDuration = queryEndTime - queryStartTime;
+    console.log(`[get_herds] Database query completed in ${queryDuration}ms`);
     if (!herds) {
         return {
             status: EnumWebResponse.ERROR,
@@ -65,29 +70,57 @@ export async function createHerd(newHerd) {
     }
 }
 export async function server_load_herd_modules() {
+    const requestReceivedTime = Date.now();
+    console.log(`[server_load_herd_modules] Request received at: ${new Date(requestReceivedTime).toISOString()}`);
     const startTime = Date.now();
-    // load herds
+    // Measure Supabase client creation
+    const supabaseStartTime = Date.now();
     const client_supabase = await newServerClient();
+    const supabaseTime = Date.now() - supabaseStartTime;
+    console.log(`[server_load_herd_modules] Supabase client creation took: ${supabaseTime}ms`);
+    // Measure database connection and initial query
+    const dbStartTime = Date.now();
     let new_herds = await get_herds(client_supabase);
+    const dbConnectionTime = Date.now() - dbStartTime;
+    console.log(`[server_load_herd_modules] Database connection and initial herds query took: ${dbConnectionTime}ms`);
     if (new_herds.status != EnumWebResponse.SUCCESS || !new_herds.data) {
+        const errorTime = Date.now();
         return {
             status: EnumWebResponse.ERROR,
             msg: "No herds found",
             data: null,
-            time_finished: Date.now(),
-            time_sent: Date.now(),
-            server_processing_time_ms: Date.now() - startTime,
+            time_finished: errorTime,
+            time_sent: errorTime,
+            server_processing_time_ms: errorTime - startTime,
         };
     }
     console.log(`[server_load_herd_modules] Loading ${new_herds.data.length} herds in parallel...`);
+    // Measure herd module creation
+    const herdModuleStartTime = Date.now();
     let new_herd_modules = [];
     const herdModulePromises = new_herds.data.map((herd) => HerdModule.from_herd(herd, client_supabase));
     new_herd_modules = await Promise.all(herdModulePromises);
-    // now serialize the herd modules
+    const herdModuleTime = Date.now() - herdModuleStartTime;
+    console.log(`[server_load_herd_modules] Herd module creation took: ${herdModuleTime}ms`);
+    // Measure serialization
+    const serializationStartTime = Date.now();
     let serialized_herd_modules = new_herd_modules.map((herd_module) => herd_module.to_serializable());
+    const serializationTime = Date.now() - serializationStartTime;
+    console.log(`[server_load_herd_modules] Serialization took: ${serializationTime}ms`);
     const endTime = Date.now();
     const totalLoadTime = endTime - startTime;
+    // Calculate detailed timing breakdown
+    const timeToClient = endTime - requestReceivedTime;
+    const processingTime = endTime - startTime;
     console.log(`[server_load_herd_modules] Loaded ${new_herds.data.length} herds in ${totalLoadTime}ms (parallel processing)`);
+    console.log(`[server_load_herd_modules] Detailed timing breakdown:`);
+    console.log(`  - Request received to start: ${startTime - requestReceivedTime}ms`);
+    console.log(`  - Supabase client creation: ${supabaseTime}ms`);
+    console.log(`  - Database connection & query: ${dbConnectionTime}ms`);
+    console.log(`  - Herd module creation: ${herdModuleTime}ms`);
+    console.log(`  - Serialization: ${serializationTime}ms`);
+    console.log(`  - Total processing time: ${processingTime}ms`);
+    console.log(`  - Total time to client: ${timeToClient}ms`);
     // Record the time when we're about to send the response
     const timeSent = Date.now();
     return {

package/dist/hooks/useScoutRefresh.js

@@ -59,14 +59,18 @@ export function useScoutRefresh(options = {}) {
             const [herdModulesResult, userResult] = await Promise.all([
                 (async () => {
                     const start = Date.now();
+                    console.log(`[useScoutRefresh] Starting herd modules request at ${new Date(start).toISOString()}`);
                     const result = await server_load_herd_modules();
                     const duration = Date.now() - start;
+                    console.log(`[useScoutRefresh] Herd modules request completed in ${duration}ms`);
                     return { result, duration, start };
                 })(),
                 (async () => {
                     const start = Date.now();
+                    console.log(`[useScoutRefresh] Starting user request at ${new Date(start).toISOString()}`);
                     const result = await server_get_user();
                     const duration = Date.now() - start;
+                    console.log(`[useScoutRefresh] User request completed in ${duration}ms`);
                     return { result, duration, start };
                 })(),
             ]);
@@ -77,6 +81,16 @@ export function useScoutRefresh(options = {}) {
             const res_new_user = userResult.result;
             const herdModulesDuration = herdModulesResult.duration;
             const userApiDuration = userResult.duration;
+            // Calculate request timing breakdown
+            const requestStartTime = parallelStartTime;
+            const requestEndTime = Date.now();
+            const totalRequestTime = requestEndTime - requestStartTime;
+            console.log(`[useScoutRefresh] Request timing breakdown:`);
+            console.log(`  - Request started at: ${new Date(requestStartTime).toISOString()}`);
+            console.log(`  - Request completed at: ${new Date(requestEndTime).toISOString()}`);
+            console.log(`  - Total request time: ${totalRequestTime}ms`);
+            console.log(`  - Parallel execution time: ${parallelDuration}ms`);
+            console.log(`  - Request overhead: ${totalRequestTime - parallelDuration}ms`);
             // Calculate network latency for herd modules
             let networkLatencyMs = 0;
             if (herdModulesResponse.status === EnumWebResponse.SUCCESS &&

package/dist/supabase/server.js

@@ -1,8 +1,14 @@
 import { createServerClient } from "@supabase/ssr";
 import { cookies } from "next/headers";
 export async function newServerClient() {
+    const startTime = Date.now();
+    console.log(`[newServerClient] Starting client creation at ${new Date(startTime).toISOString()}`);
+    const cookieStartTime = Date.now();
     const cookieStore = await cookies();
-    return createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY, {
+    const cookieTime = Date.now() - cookieStartTime;
+    console.log(`[newServerClient] Cookie retrieval took: ${cookieTime}ms`);
+    const supabaseStartTime = Date.now();
+    const client = createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY, {
         cookies: {
             getAll() {
                 return cookieStore.getAll();
@@ -19,4 +25,9 @@ export async function newServerClient() {
             },
         },
     });
+    const supabaseTime = Date.now() - supabaseStartTime;
+    console.log(`[newServerClient] Supabase client creation took: ${supabaseTime}ms`);
+    const totalTime = Date.now() - startTime;
+    console.log(`[newServerClient] Total client creation time: ${totalTime}ms`);
+    return client;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adventurelabs/scout-core",
-  "version": "1.0.63",
+  "version": "1.0.65",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",