src/core/http.ts

@@ -135,51 +135,6 @@ export class HttpClient {
       fetchOptions.body = JSON.stringify(options.body);
     }
 
-    // Extract and log SQL query details for rqlite operations
-    const isRqliteOperation = path.includes("/v1/rqlite/");
-    let queryDetails: string | null = null;
-    if (isRqliteOperation && options.body) {
-      try {
-        const body =
-          typeof options.body === "string"
-            ? JSON.parse(options.body)
-            : options.body;
-
-        if (body.sql) {
-          // Direct SQL query (query/exec endpoints)
-          queryDetails = `SQL: ${body.sql}`;
-          if (body.args && body.args.length > 0) {
-            queryDetails += ` | Args: [${body.args
-              .map((a: any) => (typeof a === "string" ? `"${a}"` : a))
-              .join(", ")}]`;
-          }
-        } else if (body.table) {
-          // Table-based query (find/find-one/select endpoints)
-          queryDetails = `Table: ${body.table}`;
-          if (body.criteria && Object.keys(body.criteria).length > 0) {
-            queryDetails += ` | Criteria: ${JSON.stringify(body.criteria)}`;
-          }
-          if (body.options) {
-            queryDetails += ` | Options: ${JSON.stringify(body.options)}`;
-          }
-          if (body.select) {
-            queryDetails += ` | Select: ${JSON.stringify(body.select)}`;
-          }
-          if (body.where) {
-            queryDetails += ` | Where: ${JSON.stringify(body.where)}`;
-          }
-          if (body.limit) {
-            queryDetails += ` | Limit: ${body.limit}`;
-          }
-          if (body.offset) {
-            queryDetails += ` | Offset: ${body.offset}`;
-          }
-        }
-      } catch (e) {
-        // Failed to parse body, ignore
-      }
-    }
-
     try {
       const result = await this.requestWithRetry(
         url.toString(),
@@ -189,42 +144,74 @@ export class HttpClient {
       );
       const duration = performance.now() - startTime;
       if (typeof console !== "undefined") {
-        const logMessage = `[HttpClient] ${method} ${path} completed in ${duration.toFixed(
+        console.log(
-          2
+          `[HttpClient] ${method} ${path} completed in ${duration.toFixed(2)}ms`
-        )}ms`;
+        );
-        if (queryDetails) {
-          console.log(logMessage);
-          console.log(`[HttpClient]   ${queryDetails}`);
-        } else {
-          console.log(logMessage);
-        }
       }
       return result;
     } catch (error) {
       const duration = performance.now() - startTime;
       if (typeof console !== "undefined") {
-        // For 404 errors on find-one calls, log at warn level (not error) since "not found" is expected
+        // Cache "key not found" (404 or error message) is expected behavior - don't log as error
-        // Application layer handles these cases in try-catch blocks
+        const isCacheGetNotFound =
-        const is404FindOne =
+          path === "/v1/cache/get" &&
+          error instanceof SDKError &&
+          (error.httpStatus === 404 ||
+            (error.httpStatus === 500 &&
+              error.message?.toLowerCase().includes("key not found")));
+
+        // "Not found" (404) for blocked_users is expected behavior - don't log as error
+        // This happens when checking if users are blocked (most users aren't blocked)
+        const isBlockedUsersNotFound =
           path === "/v1/rqlite/find-one" &&
           error instanceof SDKError &&
-          error.httpStatus === 404;
+          error.httpStatus === 404 &&
+          options.body &&
+          (() => {
+            try {
+              const body =
+                typeof options.body === "string"
+                  ? JSON.parse(options.body)
+                  : options.body;
+              return body.table === "blocked_users";
+            } catch {
+              return false;
+            }
+          })();
 
-        if (is404FindOne) {
+        // "Not found" (404) for conversation_participants is expected behavior - don't log as error
-          // Log as warning for visibility, but not as error since it's expected behavior
+        // This happens when checking if a user is a participant (e.g., on first group join)
-          console.warn(
+        const isConversationParticipantNotFound =
-            `[HttpClient] ${method} ${path} returned 404 after ${duration.toFixed(
+          path === "/v1/rqlite/find-one" &&
-              2
+          error instanceof SDKError &&
-            )}ms (expected for optional lookups)`
+          error.httpStatus === 404 &&
-          );
+          options.body &&
+          (() => {
+            try {
+              const body =
+                typeof options.body === "string"
+                  ? JSON.parse(options.body)
+                  : options.body;
+              return body.table === "conversation_participants";
+            } catch {
+              return false;
+            }
+          })();
+
+        if (
+          isCacheGetNotFound ||
+          isBlockedUsersNotFound ||
+          isConversationParticipantNotFound
+        ) {
+          // Log cache miss, non-blocked status, or non-participant status as debug/info, not error
+          // These are expected behaviors
         } else {
-          const errorMessage = `[HttpClient] ${method} ${path} failed after ${duration.toFixed(
+          console.error(
-            2
+            `[HttpClient] ${method} ${path} failed after ${duration.toFixed(
-          )}ms:`;
+              2
-          console.error(errorMessage, error);
+            )}ms:`,
-          if (queryDetails) {
+            error
-            console.error(`[HttpClient]   ${queryDetails}`);
+          );
-          }
         }
       }
       throw error;