@soulcraft/brainy 3.37.5 → 3.37.7

package/dist/storage/adapters/gcsStorage.js

@@ -146,6 +146,12 @@ export class GcsStorage extends BaseStorage {
             });
             // Initialize counts from storage
             await this.initializeCounts();
+            // CRITICAL FIX (v3.37.7): Clear any stale cache entries from previous runs
+            // This prevents cache poisoning from causing silent failures on container restart
+            prodLog.info('🧹 Clearing cache from previous run to prevent cache poisoning');
+            this.nounCacheManager.clear();
+            this.verbCacheManager.clear();
+            prodLog.info('✅ Cache cleared - starting fresh');
             this.isInitialized = true;
         }
         catch (error) {
@@ -380,12 +386,27 @@ export class GcsStorage extends BaseStorage {
      */
     async getNode(id) {
         await this.ensureInitialized();
-        // Check cache first
+        // Check cache first WITH LOGGING
         const cached = this.nounCacheManager.get(id);
-        if (cached) {
+        // DIAGNOSTIC LOGGING: Reveal cache poisoning
+        prodLog.info(`[getNode] 🔍 Cache check for ${id.substring(0, 8)}...:`, {
+            hasCached: cached !== undefined,
+            isNull: cached === null,
+            isObject: cached !== null && typeof cached === 'object',
+            type: typeof cached
+        });
+        // CRITICAL FIX: Only return cached value if it's valid (not null/undefined)
+        if (cached !== undefined && cached !== null) {
+            prodLog.info(`[getNode] ✅ Cache HIT - returning cached node for ${id.substring(0, 8)}...`);
             this.logger.trace(`Cache hit for noun ${id}`);
             return cached;
         }
+        else if (cached === null) {
+            prodLog.warn(`[getNode] ⚠️ Cache contains NULL for ${id.substring(0, 8)}... - ignoring and loading from GCS`);
+        }
+        else {
+            prodLog.info(`[getNode] ❌ Cache MISS - loading from GCS for ${id.substring(0, 8)}...`);
+        }
         // Apply backpressure
         const requestId = await this.applyBackpressure();
         try {
@@ -393,12 +414,19 @@ export class GcsStorage extends BaseStorage {
             // Get the GCS key with UUID-based sharding
             const key = this.getNounKey(id);
             // DIAGNOSTIC LOGGING: Show exact path being accessed
-            this.logger.trace(`Computed GCS key: ${key}`);
+            prodLog.info(`[getNode] 🔍 Attempting to load:`);
+            prodLog.info(`[getNode]   UUID: ${id}`);
+            prodLog.info(`[getNode]   Path: ${key}`);
+            prodLog.info(`[getNode]   Bucket: ${this.bucketName}`);
             // Download from GCS
             const file = this.bucket.file(key);
+            prodLog.info(`[getNode] 📥 Downloading file...`);
             const [contents] = await file.download();
+            prodLog.info(`[getNode] ✅ Download successful: ${contents.length} bytes`);
             // Parse JSON
+            prodLog.info(`[getNode] 🔧 Parsing JSON...`);
             const data = JSON.parse(contents.toString());
+            prodLog.info(`[getNode] ✅ JSON parsed successfully, id: ${data.id}`);
             // Convert serialized connections back to Map<number, Set<string>>
             const connections = new Map();
             for (const [level, nounIds] of Object.entries(data.connections || {})) {
@@ -413,29 +441,44 @@ export class GcsStorage extends BaseStorage {
                 level: data.level || 0
                 // NO metadata field - retrieved separately for scalability
             };
-            // Update cache
-            this.nounCacheManager.set(id, node);
+            // CRITICAL FIX: Only cache valid nodes (never cache null)
+            if (node && node.id && node.vector && Array.isArray(node.vector)) {
+                this.nounCacheManager.set(id, node);
+                prodLog.info(`[getNode] 💾 Cached node ${id.substring(0, 8)}... successfully`);
+            }
+            else {
+                prodLog.warn(`[getNode] ⚠️ NOT caching invalid node for ${id.substring(0, 8)}...`);
+            }
             this.logger.trace(`Successfully retrieved node ${id}`);
             this.releaseBackpressure(true, requestId);
             return node;
         }
         catch (error) {
             this.releaseBackpressure(false, requestId);
+            // DIAGNOSTIC LOGGING: Log EVERY error before any conditional checks
+            const key = this.getNounKey(id);
+            prodLog.error(`[getNode] ❌ EXCEPTION CAUGHT:`);
+            prodLog.error(`[getNode]   UUID: ${id}`);
+            prodLog.error(`[getNode]   Path: ${key}`);
+            prodLog.error(`[getNode]   Bucket: ${this.bucketName}`);
+            prodLog.error(`[getNode]   Error type: ${error?.constructor?.name || typeof error}`);
+            prodLog.error(`[getNode]   Error code: ${JSON.stringify(error?.code)}`);
+            prodLog.error(`[getNode]   Error message: ${error?.message || String(error)}`);
+            prodLog.error(`[getNode]   Error object:`, JSON.stringify(error, null, 2));
             // Check if this is a "not found" error
             if (error.code === 404) {
-                // DIAGNOSTIC LOGGING: Upgrade 404 errors to WARN level with full details
-                const key = this.getNounKey(id);
-                prodLog.warn(`[getNode] ❌ 404 NOT FOUND: File does not exist at GCS path: ${key}`);
-                prodLog.warn(`[getNode] UUID: ${id}`);
-                prodLog.warn(`[getNode] Bucket: ${this.bucketName}`);
-                prodLog.warn(`[getNode] This suggests a path mismatch or the file was not written correctly`);
+                prodLog.warn(`[getNode] Identified as 404 error - returning null WITHOUT caching`);
+                // CRITICAL FIX: Do NOT cache null values
                 return null;
             }
             // Handle throttling
             if (this.isThrottlingError(error)) {
+                prodLog.warn(`[getNode] Identified as throttling error - rethrowing`);
                 await this.handleThrottling(error);
                 throw error;
             }
+            // All other errors should throw, not return null
+            prodLog.error(`[getNode] Unhandled error - rethrowing`);
             this.logger.error(`Failed to get node ${id}:`, error);
             throw BrainyError.fromError(error, `getNoun(${id})`);
         }

package/dist/storage/adapters/s3CompatibleStorage.js

@@ -237,6 +237,16 @@ export class S3CompatibleStorage extends BaseStorage {
             await this.cleanupLegacyIndexFolder();
             // Initialize counts from storage
             await this.initializeCounts();
+            // CRITICAL FIX (v3.37.7): Clear any stale cache entries from previous runs
+            // This prevents cache poisoning from causing silent failures on container restart
+            const nodeCacheSize = this.nodeCache?.size || 0;
+            if (nodeCacheSize > 0) {
+                prodLog.info(`🧹 Clearing ${nodeCacheSize} cached node entries from previous run`);
+                this.nodeCache.clear();
+            }
+            else {
+                prodLog.info('🧹 Node cache is empty - starting fresh');
+            }
             this.isInitialized = true;
             this.logger.info(`Initialized ${this.serviceType} storage with bucket ${this.bucketName}`);
         }
@@ -808,60 +818,117 @@ export class S3CompatibleStorage extends BaseStorage {
      */
     async getNode(id) {
         await this.ensureInitialized();
+        // Check cache first WITH LOGGING
+        const cached = this.nodeCache.get(id);
+        // DIAGNOSTIC LOGGING: Reveal cache poisoning
+        prodLog.info(`[getNode] 🔍 Cache check for ${id.substring(0, 8)}...:`, {
+            hasCached: cached !== undefined,
+            isNull: cached === null,
+            isObject: cached !== null && typeof cached === 'object',
+            type: typeof cached
+        });
+        // CRITICAL FIX: Only return cached value if it's valid (not null/undefined)
+        if (cached !== undefined && cached !== null) {
+            prodLog.info(`[getNode] ✅ Cache HIT - returning cached node for ${id.substring(0, 8)}...`);
+            this.logger.trace(`Cache hit for node ${id}`);
+            return cached;
+        }
+        else if (cached === null) {
+            prodLog.warn(`[getNode] ⚠️ Cache contains NULL for ${id.substring(0, 8)}... - ignoring and loading from S3`);
+        }
+        else {
+            prodLog.info(`[getNode] ❌ Cache MISS - loading from S3 for ${id.substring(0, 8)}...`);
+        }
         try {
             // Import the GetObjectCommand only when needed
             const { GetObjectCommand } = await import('@aws-sdk/client-s3');
             // Use getNounKey() to properly handle sharding
             const key = this.getNounKey(id);
-            this.logger.trace(`Getting node ${id} from key: ${key}`);
+            // DIAGNOSTIC LOGGING: Show exact path being accessed
+            prodLog.info(`[getNode] 🔍 Attempting to load:`);
+            prodLog.info(`[getNode]   UUID: ${id}`);
+            prodLog.info(`[getNode]   Path: ${key}`);
+            prodLog.info(`[getNode]   Bucket: ${this.bucketName}`);
             // Try to get the node from the nouns directory
+            prodLog.info(`[getNode] 📥 Downloading file...`);
             const response = await this.s3Client.send(new GetObjectCommand({
                 Bucket: this.bucketName,
                 Key: key
             }));
             // Check if response is null or undefined
             if (!response || !response.Body) {
-                this.logger.trace(`No node found for ${id}`);
+                prodLog.warn(`[getNode] ❌ Response or Body is null/undefined`);
                 return null;
             }
             // Convert the response body to a string
             const bodyContents = await response.Body.transformToString();
-            this.logger.trace(`Retrieved node body for ${id}`);
+            prodLog.info(`[getNode] ✅ Download successful: ${bodyContents.length} bytes`);
             // Parse the JSON string
-            try {
-                const parsedNode = JSON.parse(bodyContents);
-                this.logger.trace(`Parsed node data for ${id}`);
-                // Ensure the parsed node has the expected properties
-                if (!parsedNode ||
-                    !parsedNode.id ||
-                    !parsedNode.vector ||
-                    !parsedNode.connections) {
-                    this.logger.warn(`Invalid node data for ${id}`);
-                    return null;
-                }
-                // Convert serialized connections back to Map<number, Set<string>>
-                const connections = new Map();
-                for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
-                    connections.set(Number(level), new Set(nodeIds));
-                }
-                const node = {
-                    id: parsedNode.id,
-                    vector: parsedNode.vector,
-                    connections,
-                    level: parsedNode.level || 0
-                };
-                this.logger.trace(`Successfully retrieved node ${id}`);
-                return node;
-            }
-            catch (parseError) {
-                this.logger.error(`Failed to parse node data for ${id}:`, parseError);
+            prodLog.info(`[getNode] 🔧 Parsing JSON...`);
+            const parsedNode = JSON.parse(bodyContents);
+            prodLog.info(`[getNode] ✅ JSON parsed successfully, id: ${parsedNode.id}`);
+            // Ensure the parsed node has the expected properties
+            if (!parsedNode ||
+                !parsedNode.id ||
+                !parsedNode.vector ||
+                !parsedNode.connections) {
+                prodLog.error(`[getNode] ❌ Invalid node data structure for ${id}`);
+                prodLog.error(`[getNode]   Has id: ${!!parsedNode?.id}`);
+                prodLog.error(`[getNode]   Has vector: ${!!parsedNode?.vector}`);
+                prodLog.error(`[getNode]   Has connections: ${!!parsedNode?.connections}`);
                 return null;
             }
+            // Convert serialized connections back to Map<number, Set<string>>
+            const connections = new Map();
+            for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
+                connections.set(Number(level), new Set(nodeIds));
+            }
+            const node = {
+                id: parsedNode.id,
+                vector: parsedNode.vector,
+                connections,
+                level: parsedNode.level || 0
+            };
+            // CRITICAL FIX: Only cache valid nodes (never cache null)
+            if (node && node.id && node.vector && Array.isArray(node.vector)) {
+                this.nodeCache.set(id, node);
+                prodLog.info(`[getNode] 💾 Cached node ${id.substring(0, 8)}... successfully`);
+            }
+            else {
+                prodLog.warn(`[getNode] ⚠️ NOT caching invalid node for ${id.substring(0, 8)}...`);
+            }
+            this.logger.trace(`Successfully retrieved node ${id}`);
+            return node;
         }
         catch (error) {
-            // Node not found or other error
-            this.logger.trace(`Node not found for ${id}`);
-            return null;
+            // DIAGNOSTIC LOGGING: Log EVERY error before any conditional checks
+            const key = this.getNounKey(id);
+            prodLog.error(`[getNode] ❌ EXCEPTION CAUGHT:`);
+            prodLog.error(`[getNode]   UUID: ${id}`);
+            prodLog.error(`[getNode]   Path: ${key}`);
+            prodLog.error(`[getNode]   Bucket: ${this.bucketName}`);
+            prodLog.error(`[getNode]   Error type: ${error?.constructor?.name || typeof error}`);
+            prodLog.error(`[getNode]   Error name: ${error?.name}`);
+            prodLog.error(`[getNode]   Error code: ${JSON.stringify(error?.Code || error?.code)}`);
+            prodLog.error(`[getNode]   Error message: ${error?.message || String(error)}`);
+            prodLog.error(`[getNode]   HTTP status: ${error?.$metadata?.httpStatusCode}`);
+            prodLog.error(`[getNode]   Error object:`, JSON.stringify(error, null, 2));
+            // Check if this is a "not found" error (S3 uses "NoSuchKey")
+            if (error?.name === 'NoSuchKey' || error?.Code === 'NoSuchKey' || error?.$metadata?.httpStatusCode === 404) {
+                prodLog.warn(`[getNode] Identified as 404/NoSuchKey error - returning null WITHOUT caching`);
+                // CRITICAL FIX: Do NOT cache null values
+                return null;
+            }
+            // Handle throttling
+            if (this.isThrottlingError(error)) {
+                prodLog.warn(`[getNode] Identified as throttling error - rethrowing`);
+                await this.handleThrottling(error);
+                throw error;
+            }
+            // All other errors should throw, not return null
+            prodLog.error(`[getNode] Unhandled error - rethrowing`);
+            this.logger.error(`Failed to get node ${id}:`, error);
+            throw BrainyError.fromError(error, `getNoun(${id})`);
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.37.5",
+  "version": "3.37.7",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. 31 nouns × 40 verbs for infinite expressiveness.",
   "main": "dist/index.js",
   "module": "dist/index.js",