cds-caching 1.0.0 → 1.1.0

package/README.md

@@ -1,4 +1,6 @@
 # Welcome to cds-caching
+[![npm version](https://img.shields.io/npm/v/cds-caching)](https://www.npmjs.com/package/cds-caching/common)
+[![monthly downloads](https://img.shields.io/npm/dm/cds-caching)](https://www.npmjs.com/package/cds-caching)
 
 ## Overview
 
@@ -136,45 +138,27 @@ await cache.set(data, value, {
 
 For detailed API documentation, see [Programmatic API Reference](docs/programmatic-api.md). 
 
-### Installation
-
-Installing and using cds-caching is straightforward since it's a CAP plugin. Simply run:
-
-```bash
-npm install cds-caching
-```
-
-### TypeScript Support
+### Example Application
 
-cds-caching includes comprehensive TypeScript definitions. The library is written in JavaScript but provides full TypeScript support for better development experience.
-
-#### Basic Usage with TypeScript
+The cds-caching plugin includes a comprehensive example application demonstrating various caching use cases and a UI5-based dashboard for monitoring cache performance.
 
-```typescript
-import { CachingService, CacheOptions, ReadThroughResult } from 'cds-caching';
+![Cache Dashboard](./docs/dashboard.jpg)
 
-const cache = await cds.connect.to('caching') as CachingService;
+The example consists of:
+- **Backend Application** (`examples/app/`) - A CAP application showing annotation-based and programmatic caching patterns
+- **Dashboard** (`examples/dashboard/`) - A UI5-based monitoring interface with real-time metrics, key-level analytics, and historical data
 
-// Basic cache operations
-await cache.set('my-key', { data: 'value' }, { ttl: 3600 });
-const value = await cache.get('my-key');
+[See the full Example Application Guide →](docs/example-app.md)
 
-// Read-through operations with full type safety
-const { result, cacheKey, metadata } = await cache.rt.send(request, service, {
-  ttl: 1800,
-  tags: ['user-data']
-});
 
-// Function wrapping with type inference
-const cachedFunction = cache.rt.wrap('expensive-operation', async (id: string) => {
-  return await this.performExpensiveOperation(id);
-});
+### Installation
 
-const { result: operationResult } = await cachedFunction('user-123');
+Installing and using cds-caching is straightforward since it's a CAP plugin. Simply run:
 
+```bash
+npm install cds-caching
 ```
 
-
 ### Configuration
 
 The cds-caching plugin supports comprehensive configuration through `package.json`. Here are all available configuration options:
@@ -212,6 +196,7 @@ The cds-caching plugin supports comprehensive configuration through `package.jso
         "namespace": "caching",
         "store": "in-memory", // "in-memory", "sqlite", or "redis"
         "compression": "lz4", // "lz4" or "gzip"
+        "throwOnErrors": false, // Whether basic operations should throw errors (default: false)
         "credentials": {
           // Redis configuration
           "host": "localhost",
@@ -253,6 +238,36 @@ Configure default key templates for read-through operations:
 
 **Default behavior** (if not configured): All context elements are disabled by default.
 
+#### Error Handling Configuration
+
+Configure how the caching service handles errors:
+
+```json
+{
+  "cds": {
+    "requires": {
+      "caching": {
+        ...
+        "throwOnErrors": true,      // Basic operations (set, get, delete, has) throw errors
+        // Default: false - operations return undefined/null instead of throwing
+      }
+    }
+  }
+}
+```
+
+**Error Handling Behavior:**
+
+- **Basic Operations** (`set`, `get`, `delete`, `has`):
+  - When `throwOnErrors: false` (default): Operations return `undefined`/`null` on errors
+  - When `throwOnErrors: true`: Operations throw errors for connection issues, etc.
+
+- **Read-Through Operations** (`rt.run`, `rt.send`, `rt.wrap`, `rt.exec`):
+  - Never throw errors, regardless of `throwOnErrors` setting
+  - Include `cacheErrors` array in response when errors occur
+  - Always fetch from remote service when cache operations fail
+  - Log errors for monitoring and debugging
+
 #### Environment-Specific Configuration
 
 You can override settings for different environments:
@@ -318,6 +333,7 @@ cds-caching provides 3 storage options:
 - Works across multiple app instances, making it ideal for scalable applications
 - Available on SAP BTP via hyperscaler options (e.g., AWS, Azure, Google Cloud)
 - Even trial accounts provide Redis access
+- Redis will be non-blocking
 
 #### Redis Development Setup
 
@@ -431,6 +447,31 @@ await cache.delete("bp:1000001")
 await cache.clear()
 ```
 
+**Error Handling for Basic Operations:**
+
+```javascript
+// With throwOnErrors: false (default)
+try {
+  const value = await cache.get("bp:1000001")
+  if (value === undefined) {
+    // Handle cache miss or error
+    console.log("Value not found or cache error occurred")
+  }
+} catch (error) {
+  // Only thrown for non-cache related errors
+  console.error("Unexpected error:", error)
+}
+
+// With throwOnErrors: true
+try {
+  const value = await cache.get("bp:1000001")
+  // Value will be undefined if not found, but errors will be thrown
+} catch (error) {
+  // Errors thrown for connection issues, etc.
+  console.error("Cache error:", error)
+}
+```
+
 #### 2. CQN Query Caching
 
 For more advanced CAP integration, cache CAP's CQN queries directly. By passing in the query, a dynamic key is generated based on the CQN structure of the query. Note, that passing in queries with dynamic parameters (e.g. `SELECT.from(Foo).where({id: 1})`) will result in a different key for each query execution.
@@ -463,6 +504,23 @@ Because the cache key has been dynamically created at runtime, it will also be r
 const { result, cacheKey } = await cache.rt.run(query, db)
 ```
 
+**Error Handling for Read-Through Operations:**
+
+Read-through operations never throw errors, even when cache operations fail. Instead, they include error information in the response:
+
+```javascript
+// Read-through operations always return a result, even on cache errors
+const { result, cacheKey, metadata, cacheErrors } = await cache.rt.run(query, db)
+
+if (cacheErrors && cacheErrors.length > 0) {
+  console.log("Cache errors occurred:", cacheErrors)
+  // Result will be fetched from remote service despite cache errors
+}
+
+// The result is always available, regardless of cache errors
+return result
+```
+
 #### 3. RemoteService Request-Level Caching
 
 Cache entire CAP requests with context awareness (e.g. user, tenant, locale, etc.), which is useful for caching slow remote service calls or even application services. The caching service will automatically generate a key for the request based on the request object and the current user, tenant and locale (if not configured otherwise).
@@ -770,6 +828,36 @@ for await (const entry of iterator) {
 
 This will return an iterator over all cache entries. You can use this to traverse all cache entries and invalidate them based on a specific condition. You should only use this for small caches (e.g. by using multiple caching services with different namespaces).
 
+### TypeScript Support
+
+cds-caching includes comprehensive TypeScript definitions. The library is written in JavaScript but provides full TypeScript support for better development experience.
+
+#### Basic Usage with TypeScript
+
+```typescript
+import { CachingService, CacheOptions, ReadThroughResult } from 'cds-caching';
+
+const cache = await cds.connect.to('caching') as CachingService;
+
+// Basic cache operations
+await cache.set('my-key', { data: 'value' }, { ttl: 3600 });
+const value = await cache.get('my-key');
+
+// Read-through operations with full type safety
+const { result, cacheKey, metadata } = await cache.rt.send(request, service, {
+  ttl: 1800,
+  tags: ['user-data']
+});
+
+// Function wrapping with type inference
+const cachedFunction = cache.rt.wrap('expensive-operation', async (id: string) => {
+  return await this.performExpensiveOperation(id);
+});
+
+const { result: operationResult } = await cachedFunction('user-123');
+
+```
+
 ### OData Service Caching Considerations
 
 While caching individual requests can improve performance, **caching an entire OData service is generally not recommended**. Here's why:

package/lib/CachingService.js

@@ -16,7 +16,9 @@ class CachingService extends cds.Service {
         this.options = this.options || {
             store: null,
             compression: null,
-            credentials: {}
+            credentials: {},
+            namespace: null,
+            throwOnErrors: false,
         };
 
         // Initialize managers
@@ -164,7 +166,8 @@ class CachingService extends cds.Service {
         if (typeof args[0] !== "object" || !args[1].send || typeof args[1] !== "object" || args[0].method !== "GET") {
             return super.send(...args);
         } else {
-            return (await this.rt.send(...args)).result;
+            const result = await this.rt.send(...args);
+            return result.result;
         }
     }
 
@@ -177,7 +180,8 @@ class CachingService extends cds.Service {
         if (typeof args[0] !== "object" && !["Request", "NoaRequest", "ODataRequest", "cds.ql"].includes(args[0].constructor.name)) {
             return super.run(...args);
         } else {
-            return (await this.rt.run(...args)).result;
+            const result = await this.rt.run(...args);  
+            return result.result;
         }
     }
 

package/lib/operations/AsyncOperations.js

@@ -7,6 +7,36 @@ class AsyncOperations {
         this.keyManager = keyManager;
         this.statistics = statistics;
         this.runtimeConfigManager = runtimeConfigManager;
+        this.log = console; // Default logger
+    }
+
+    /**
+     * Safely execute cache operations with error handling
+     * @param {Function} operation - The cache operation to execute
+     * @param {string} operationName - Name of the operation for logging
+     * @param {object} context - Context information for logging
+     * @returns {Promise<object>} - The result with error information
+     */
+    async safeCacheOperation(operation, operationName, context = {}) {
+        try {
+            const result = await operation();
+            return { success: true, result, error: null };
+        } catch (error) {
+            this.log.warn(`Cache ${operationName} failed:`, {
+                error: error.message,
+                stack: error.stack,
+                context: context
+            });
+            return { 
+                success: false, 
+                result: null, 
+                error: {
+                    message: error.message,
+                    operation: operationName,
+                    context: context
+                }
+            };
+        }
     }
 
     /**
@@ -85,25 +115,91 @@ class AsyncOperations {
                 cacheOptions: JSON.stringify(options)
             };
 
-            if (await this.cache.has(cacheKey)) {
+            // Safely check if key exists in cache
+            const hasKeyResult = await this.safeCacheOperation(
+                () => this.cache.has(cacheKey),
+                'has',
+                { key: cacheKey, functionName: asyncFunction.name || 'anonymous' }
+            );
+
+            const hasKey = hasKeyResult.success && hasKeyResult.result;
+            const cacheErrors = [];
+
+            if (hasKey) {
                 const latency = this.getElapsedMs(startTime);
-                this.statistics.recordHit(latency, cacheKey, metadata);
+                
+                // Safely record hit statistics
+                const hitStatsResult = await this.safeCacheOperation(
+                    () => this.statistics.recordHit(latency, cacheKey, metadata),
+                    'recordHit',
+                    { key: cacheKey, latency }
+                );
+                if (!hitStatsResult.success) {
+                    cacheErrors.push(hitStatsResult.error);
+                }
+
+                // Safely get value from cache
+                const getResult = await this.safeCacheOperation(
+                    () => this.cache.send("GET", { key: cacheKey }),
+                    'get',
+                    { key: cacheKey }
+                );
+
+                if (getResult.success && getResult.result?.value !== undefined) {
+                    return { 
+                        result: getResult.result.value, 
+                        cacheKey, 
+                        metadata: { hit: true, latency },
+                        cacheErrors: cacheErrors
+                    };
+                }
+            }
 
-                const result = await this.cache.send("GET", { key: cacheKey });
-                return { result: result?.value || result, cacheKey, metadata: { hit: true, latency } };
-            } else {
+            // Cache miss or cache error - delegate to underlying function
+            try {
                 const response = await asyncFunction(...args);
                 const latency = this.getElapsedMs(startTime);
-                this.statistics.recordMiss(latency, cacheKey, metadata);
+                
+                // Safely record miss statistics
+                const missStatsResult = await this.safeCacheOperation(
+                    () => this.statistics.recordMiss(latency, cacheKey, metadata),
+                    'recordMiss',
+                    { key: cacheKey, latency }
+                );
+                if (!missStatsResult.success) {
+                    cacheErrors.push(missStatsResult.error);
+                }
 
+                // Safely store in cache
                 const wrappedValue = {
                     value: response,
                     tags: options.tags || [],
                     timestamp: Date.now()
                 };
-                await this.cache.send("SET", { key: cacheKey, value: wrappedValue, ttl: options.ttl || 0 });
+                
+                const setResult = await this.safeCacheOperation(
+                    () => this.cache.send("SET", { key: cacheKey, value: wrappedValue, ttl: options.ttl || 0 }),
+                    'set',
+                    { key: cacheKey, ttl: options.ttl }
+                );
+                if (!setResult.success) {
+                    cacheErrors.push(setResult.error);
+                }
 
-                return { result: response, cacheKey, metadata: { hit: false, latency } };
+                return { 
+                    result: response, 
+                    cacheKey, 
+                    metadata: { hit: false, latency },
+                    cacheErrors: cacheErrors
+                };
+            } catch (functionError) {
+                // If the underlying function fails, throw the error
+                this.log.error('Function execution failed:', {
+                    error: functionError.message,
+                    functionName: asyncFunction.name || 'anonymous',
+                    key: cacheKey
+                });
+                throw functionError;
             }
         }
     }
@@ -137,24 +233,91 @@ class AsyncOperations {
             cacheOptions: JSON.stringify(options)
         };
 
-        if (await this.cache.has(cacheKey)) {
+        // Safely check if key exists in cache
+        const hasKeyResult = await this.safeCacheOperation(
+            () => this.cache.has(cacheKey),
+            'has',
+            { key: cacheKey, functionName: asyncFunction.name || 'anonymous' }
+        );
+
+        const hasKey = hasKeyResult.success && hasKeyResult.result;
+        const cacheErrors = [];
+
+        if (hasKey) {
             const latency = this.getElapsedMs(startTime);
-            this.statistics.recordHit(latency, cacheKey, metadata);
-            const result = await this.cache.send("GET", { key: cacheKey });
-            return { result: result?.value || result, cacheKey, metadata: { hit: true, latency } };
-        } else {
+            
+            // Safely record hit statistics
+            const hitStatsResult = await this.safeCacheOperation(
+                () => this.statistics.recordHit(latency, cacheKey, metadata),
+                'recordHit',
+                { key: cacheKey, latency }
+            );
+            if (!hitStatsResult.success) {
+                cacheErrors.push(hitStatsResult.error);
+            }
+
+            // Safely get value from cache
+            const getResult = await this.safeCacheOperation(
+                () => this.cache.send("GET", { key: cacheKey }),
+                'get',
+                { key: cacheKey }
+            );
+
+            if (getResult.success && getResult.result?.value !== undefined) {
+                return { 
+                    result: getResult.result.value, 
+                    cacheKey, 
+                    metadata: { hit: true, latency },
+                    cacheErrors: cacheErrors
+                };
+            }
+        }
+
+        // Cache miss or cache error - delegate to underlying function
+        try {
             const response = await asyncFunction(...args);
             const latency = this.getElapsedMs(startTime);
-            this.statistics.recordMiss(latency, cacheKey, metadata);
+            
+            // Safely record miss statistics
+            const missStatsResult = await this.safeCacheOperation(
+                () => this.statistics.recordMiss(latency, cacheKey, metadata),
+                'recordMiss',
+                { key: cacheKey, latency }
+            );
+            if (!missStatsResult.success) {
+                cacheErrors.push(missStatsResult.error);
+            }
 
+            // Safely store in cache
             const wrappedValue = {
                 value: response,
                 tags: options.tags || [],
                 timestamp: Date.now()
             };
-            await this.cache.send("SET", { key: cacheKey, value: wrappedValue, ttl: options.ttl || 0 });
+            
+            const setResult = await this.safeCacheOperation(
+                () => this.cache.send("SET", { key: cacheKey, value: wrappedValue, ttl: options.ttl || 0 }),
+                'set',
+                { key: cacheKey, ttl: options.ttl }
+            );
+            if (!setResult.success) {
+                cacheErrors.push(setResult.error);
+            }
 
-            return { result: response, cacheKey, metadata: { hit: false, latency } };
+            return { 
+                result: response, 
+                cacheKey, 
+                metadata: { hit: false, latency },
+                cacheErrors: cacheErrors
+            };
+        } catch (functionError) {
+            // If the underlying function fails, throw the error
+            this.log.error('Function execution failed:', {
+                error: functionError.message,
+                functionName: asyncFunction.name || 'anonymous',
+                key: cacheKey
+            });
+            throw functionError;
         }
     }
 

package/lib/operations/BasicOperations.js

@@ -70,7 +70,15 @@ class BasicOperations {
      */
     async has(key) {
         const createdKey = this.keyManager.createKey(key);
-        return this.cache.cache.has(createdKey);
+        try {
+            return await this.cache.cache.has(createdKey);
+        } catch (error) {
+            if (this.cache.options.throwOnErrors) {
+                throw error;
+            } else {
+                return false; // We don't want to throw errors here
+            }
+        }
     }
 
     /**
@@ -101,7 +109,9 @@ class BasicOperations {
      * @returns {Promise<void>}
      */
     async clear() {
-        await this.cache.send('CLEAR');
+        await this.cache.send('CLEAR', {
+            deleteAll: true
+        });
 
         // Record the native clear operation
         const metadata = {

package/lib/operations/CapOperations.js

@@ -15,9 +15,39 @@ class CapOperations {
         this.statistics = statistics;
         this.tagResolver = new TagResolver();
         this.runtimeConfigManager = runtimeConfigManager;
+        this.log = log || console;
     }
 
-
+    /**
+     * Safely execute cache operations with error handling
+     * @param {Function} operation - The cache operation to execute
+     * @param {string} operationName - Name of the operation for logging
+     * @param {object} context - Context information for logging
+     * @returns {Promise<object>} - The result with error information
+     */
+    async safeCacheOperation(operation, operationName, context = {}) {
+        try {
+            const result = await operation();
+            this.log.info('REEEESULT', { result });
+            return { success: true, result, error: null };
+        } catch (error) {
+            this.log.warn(`Cache ${operationName} failed:`, {
+                error: error.message,
+                stack: error.stack,
+                context: context
+            });
+            
+            return { 
+                success: false, 
+                result: null, 
+                error: {
+                    message: error.message,
+                    operation: operationName,
+                    context: context
+                }
+            };
+        }
+    }
 
     /**
      * Send a request with caching with read-through capabilities.
@@ -34,7 +64,7 @@ class CapOperations {
         }
 
         if (['POST', 'PUT', 'DELETE', 'PATCH'].includes(request.method?.toUpperCase()) || !service.send) {
-            return { result: null, cacheKey: null, metadata: { hit: false, latency: 0 } };
+            return { result: null, cacheKey: null, metadata: { hit: false, latency: 0 }, cacheErrors: [] };
         }
 
         const keyParts = {
@@ -79,31 +109,94 @@ class CapOperations {
             cacheOptions: JSON.stringify(requestOptions)
         };
 
-        if (await this.cache.has(key)) {
+        // Safely check if key exists in cache
+        const hasKeyResult = await this.safeCacheOperation(
+            () => this.cache.has(key),
+            'has',
+            { key, serviceName: service.name }
+        );
+
+        const hasKey = hasKeyResult.success && hasKeyResult.result;
+        const cacheErrors = [];
+
+        if (hasKey) {
             const latency = this.getElapsedMs(startTime);
 
-            this.statistics.recordHit(latency, key, metadata);
+            // Safely record hit statistics
+            const hitStatsResult = await this.safeCacheOperation(
+                () => this.statistics.recordHit(latency, key, metadata),
+                'recordHit',
+                { key, latency }
+            );
+            if (!hitStatsResult.success) {
+                cacheErrors.push(hitStatsResult.error);
+            }
 
-            const wrappedValue = await this.cache.send("GET", { key });
-            return { result: wrappedValue?.value, cacheKey: key, metadata: { hit: true, latency: latency } };
-        } else {
+            // Safely get value from cache
+            const getResult = await this.safeCacheOperation(
+                () => this.cache.send("GET", { key }),
+                'get',
+                { key }
+            );
+
+            if (getResult.success && getResult.result?.value !== undefined) {
+                return { 
+                    result: getResult.result.value, 
+                    cacheKey: key, 
+                    metadata: { hit: true, latency: latency },
+                    cacheErrors: cacheErrors
+                };
+            }
+        }
+
+        // Cache miss or cache error - delegate to underlying service
+        try {
             const response = await service.send(request);
             const totalLatency = this.getElapsedMs(startTime);
-            this.statistics.recordMiss(totalLatency, key, metadata);
+            
+            // Safely record miss statistics
+            const missStatsResult = await this.safeCacheOperation(
+                () => this.statistics.recordMiss(totalLatency, key, metadata),
+                'recordMiss',
+                { key, latency: totalLatency }
+            );
+            if (!missStatsResult.success) {
+                cacheErrors.push(missStatsResult.error);
+            }
 
+            // Safely store in cache
             const wrappedValue = {
                 value: response,
                 tags: this.tagResolver.resolveTags(requestOptions.tags, response, { ...request.params, user: request.user?.id, tenant: request.tenant, locale: request.locale, hash: this.keyManager.createContentHash(request) }),
                 timestamp: Date.now()
             };
-            await this.cache.send("SET", { key, value: wrappedValue, ttl: requestOptions.ttl || 0 });
+            
+            const setResult = await this.safeCacheOperation(
+                () => this.cache.send("SET", { key, value: wrappedValue, ttl: requestOptions.ttl || 0 }),
+                'set',
+                { key, ttl: requestOptions.ttl }
+            );
+            if (!setResult.success) {
+                cacheErrors.push(setResult.error);
+            }
 
-            return { result: response, cacheKey: key, metadata: { hit: false, latency: totalLatency } };
+            return { 
+                result: response, 
+                cacheKey: key, 
+                metadata: { hit: false, latency: totalLatency },
+                cacheErrors: cacheErrors
+            };
+        } catch (serviceError) {
+            // If the underlying service fails, throw the error
+            this.log.error('Service operation failed:', {
+                error: serviceError.message,
+                serviceName: service.name,
+                key: key
+            });
+            throw serviceError;
         }
     }
 
-
-
     /**
      * Run a cached operation with automatic key generation
      * @param {object} req - the request object
@@ -133,34 +226,87 @@ class CapOperations {
 
                     // Track cache operation timing
                     const startTime = process.hrtime();
-                    const wrappedValue = await this.cache.send("GET", { key: req.cacheKey });
-                    const cacheHit = wrappedValue?.value !== undefined;
+                    
+                    // Safely get value from cache
+                    const getResult = await this.safeCacheOperation(
+                        () => this.cache.send("GET", { key: req.cacheKey }),
+                        'get',
+                        { key: req.cacheKey, serviceName: req.target?.name }
+                    );
+                    
+                    const cacheHit = getResult.success && getResult.result?.value !== undefined;
                     const cacheLatency = this.getElapsedMs(startTime);
                     const metadata = this.extractMetadataFromRequest(req);
+                    const cacheErrors = [];
 
                     if (cacheHit) {
                         // Cache hit
-                        this.statistics.recordHit(cacheLatency, req.cacheKey, metadata);
+                        const hitStatsResult = await this.safeCacheOperation(
+                            () => this.statistics.recordHit(cacheLatency, req.cacheKey, metadata),
+                            'recordHit',
+                            { key: req.cacheKey, latency: cacheLatency }
+                        );
+                        if (!hitStatsResult.success) {
+                            cacheErrors.push(hitStatsResult.error);
+                        }
+                        
                         req.res?.setHeader('x-sap-cap-cache', "hit");
-
-                        const wrappedValue = await this.cache.send("GET", { key: req.cacheKey });
-                        return { result: wrappedValue?.value, cacheKey: req.cacheKey, metadata: { hit: true, latency: cacheLatency } };
+                        return { 
+                            result: getResult.result.value, 
+                            cacheKey: req.cacheKey, 
+                            metadata: { hit: true, latency: cacheLatency },
+                            cacheErrors: cacheErrors
+                        };
                     } else {
                         // Cache miss - track the backend operation
-                        const response = await next();
-                        const totalLatency = this.getElapsedMs(startTime);
-
-                        // Track the miss with total latency (cache lookup + backend operation)
-                        this.statistics.recordMiss(totalLatency, req.cacheKey, metadata);
-                        req.res?.setHeader('x-sap-cap-cache', "miss");
+                        try {
+                            const response = await next();
+                            const totalLatency = this.getElapsedMs(startTime);
 
-                        const wrappedValue = {
-                            value: response,
-                            tags: this.tagResolver.resolveTags(req.cacheOptions.tags, response, { ...req.params, hash: this.keyManager.createContentHash(req) }),
-                            timestamp: Date.now()
-                        };
-                        await this.cache.send("SET", { key: req.cacheKey, value: wrappedValue, ttl: req.cacheOptions.ttl || 0 });
-                        return { result: response, cacheKey: req.cacheKey, metadata: { hit: false, latency: totalLatency } };
+                            // Safely record miss statistics
+                            const missStatsResult = await this.safeCacheOperation(
+                                () => this.statistics.recordMiss(totalLatency, req.cacheKey, metadata),
+                                'recordMiss',
+                                { key: req.cacheKey, latency: totalLatency }
+                            );
+                            if (!missStatsResult.success) {
+                                cacheErrors.push(missStatsResult.error);
+                            }
+                            
+                            req.res?.setHeader('x-sap-cap-cache', "miss");
+
+                            // Safely store in cache
+                            const wrappedValue = {
+                                value: response,
+                                tags: this.tagResolver.resolveTags(req.cacheOptions.tags, response, { ...req.params, hash: this.keyManager.createContentHash(req) }),
+                                timestamp: Date.now()
+                            };
+                            
+                            const setResult = await this.safeCacheOperation(
+                                () => this.cache.send("SET", { key: req.cacheKey, value: wrappedValue, ttl: req.cacheOptions.ttl || 0 }),
+                                'set',
+                                { key: req.cacheKey, ttl: req.cacheOptions.ttl }
+                            );
+
+                            if (!setResult.success) {
+                                cacheErrors.push(setResult.error);
+                            }
+                            
+                            return { 
+                                result: response, 
+                                cacheKey: req.cacheKey, 
+                                metadata: { hit: false, latency: totalLatency },
+                                cacheErrors: cacheErrors
+                            };
+                        } catch (serviceError) {
+                            // If the underlying service fails, throw the error
+                            this.log.error('Service operation failed:', {
+                                error: serviceError.message,
+                                serviceName: req.target?.name,
+                                key: req.cacheKey
+                            });
+                            throw serviceError;
+                        }
                     }
                 case "cds.ql":
                     const query = arg1;
@@ -177,7 +323,15 @@ class CapOperations {
 
                         // Track cache operation timing
                         const startTime = process.hrtime();
-                        const hasCachedValue = await this.cache.has(query.cacheKey);
+                        
+                        // Safely check if key exists in cache
+                        const hasCachedValueResult = await this.safeCacheOperation(
+                            () => this.cache.has(query.cacheKey),
+                            'has',
+                            { key: query.cacheKey, serviceName: srv?.name }
+                        );
+                        
+                        const hasCachedValue = hasCachedValueResult.success && hasCachedValueResult.result;
                         const cacheLatency = this.getElapsedMs(startTime);
                         const metadata = {
                             dataType: 'Query',
@@ -197,35 +351,89 @@ class CapOperations {
                             }),
                             cacheOptions: JSON.stringify(options)
                         };
+                        const cacheErrors = [];
 
                         if (hasCachedValue) {
                             // Cache hit
-                            this.statistics.recordHit(cacheLatency, query.cacheKey, metadata);
+                            const hitStatsResult = await this.safeCacheOperation(
+                                () => this.statistics.recordHit(cacheLatency, query.cacheKey, metadata),
+                                'recordHit',
+                                { key: query.cacheKey, latency: cacheLatency }
+                            );
+                            if (!hitStatsResult.success) {
+                                cacheErrors.push(hitStatsResult.error);
+                            }
+
+                            const getResult = await this.safeCacheOperation(
+                                () => this.cache.send("GET", { key: query.cacheKey }),
+                                'get',
+                                { key: query.cacheKey }
+                            );
+                            
+                            if (getResult.success && getResult.result?.value !== undefined) {
+                                                            return { 
+                                result: getResult.result.value, 
+                                cacheKey: query.cacheKey, 
+                                metadata: { hit: true, latency: cacheLatency },
+                                cacheErrors: cacheErrors
+                            };
+                            }
+                        }
 
-                            const wrappedValue = await this.cache.send("GET", { key: query.cacheKey });
-                            return { result: wrappedValue?.value, cacheKey: query.cacheKey, metadata: { hit: true, latency: cacheLatency } };
-                        } else {
-                            // Cache miss
+                        // Cache miss or cache error
+                        try {
                             const data = await srv.run(query);
                             const totalLatency = this.getElapsedMs(startTime);
 
-                            // Track the miss with total latency (cache lookup + backend operation)
-                            this.statistics.recordMiss(totalLatency, query.cacheKey, metadata);
-
+                            // Safely record miss statistics
+                            const missStatsResult = await this.safeCacheOperation(
+                                () => this.statistics.recordMiss(totalLatency, query.cacheKey, metadata),
+                                'recordMiss',
+                                { key: query.cacheKey, latency: totalLatency }
+                            );
+                            if (!missStatsResult.success) {
+                                cacheErrors.push(missStatsResult.error);
+                            }
+
+                            // Safely store in cache
                             const wrappedValue = {
                                 value: data,
                                 tags: this.tagResolver.resolveTags(options.tags, data, { ...query.params, hash: this.keyManager.createKey(query, { serviceName: srv?.name, template: '{hash}' }) }),
                                 timestamp: Date.now()
                             };
-                            await this.cache.send("SET", { key: query.cacheKey, value: wrappedValue, ttl: options.ttl || 0 });
-                            return { result: data, cacheKey: query.cacheKey, metadata: { hit: false, latency: totalLatency } };
+                            
+                            const setResult = await this.safeCacheOperation(
+                                () => this.cache.send("SET", { key: query.cacheKey, value: wrappedValue, ttl: options.ttl || 0 }),
+                                'set',
+                                { key: query.cacheKey, ttl: options.ttl }
+                            );
+                            if (!setResult.success) {
+                                cacheErrors.push(setResult.error);
+                            }
+
+                            this.log.info('REEEESULT', { setResult, cacheErrors, wrappedValue });
+                            
+                            return { 
+                                result: data, 
+                                cacheKey: query.cacheKey, 
+                                metadata: { hit: false, latency: totalLatency },
+                                cacheErrors: cacheErrors
+                            };
+                        } catch (serviceError) {
+                            // If the underlying service fails, throw the error
+                            this.log.error('Service operation failed:', {
+                                error: serviceError.message,
+                                serviceName: srv?.name,
+                                key: query.cacheKey
+                            });
+                            throw serviceError;
                         }
                     } else {
                         return srv.run(query);
                     }
             }
         }
-        return null;
+        return { result: null, cacheKey: null, metadata: { hit: false, latency: 0 }, cacheErrors: [] };
     }
 
     /**

package/lib/support/CacheStoreManager.js

@@ -10,6 +10,7 @@ const { default: KeyvGzip } = require('@keyv/compress-gzip');
 class CacheStoreManager {
     constructor(options = {}) {
         this.options = options;
+        this.log = cds.log('cds-caching')
     }
 
     /**
@@ -22,10 +23,11 @@ class CacheStoreManager {
         const store = this._createStoreInstance(options);
         const cacheOptions = this._createCacheOptions(options, cacheName);
         const cache = new Keyv(cacheOptions);
+        cache.throwOnErrors = options.throwOnErrors;
 
         // Set up error handling
         cache.on('error', err => {
-            console.error(`Cache error for ${cacheName}:`, err);
+            this.log.error(`Cache error for ${cacheName}:`, err);
         });
 
         // Set up cleanup function
@@ -47,10 +49,25 @@ class CacheStoreManager {
                     busyTimeout: options.credentials?.busyTimeout || 10000
                 });
             case "redis":
-                return new KeyvRedis({
+                const store = new KeyvRedis({
                     ...options.credentials,
                     ...(options.credentials?.uri ? { url: options.credentials?.uri } : {}),
+                    ...{ throwOnConnectErrors: options.throwOnErrors, useKeyPrefix: false, throwOnErrors: options.throwOnErrors }
                 });
+
+                if (options.throwOnErrors) {
+                    store.throwOnConnectErrors = false; // We want to handle the errors ourselves
+                    store.throwOnErrors = true;
+                    const redisClient = store.client;
+                    if (redisClient.options) {
+                        redisClient.options.disableOfflineQueue = true;
+                        if (redisClient.options.socket) {
+                            redisClient.options.socket.reconnectStrategy = false;
+                        }
+                    }
+                }
+
+                return store;
             default:
                 return new Map();
         }
@@ -93,7 +110,7 @@ class CacheStoreManager {
                 try {
                     await store.disconnect();
                 } catch (err) {
-                    console.error(`Error disconnecting from store for ${cacheName}:`, err);
+                    this.log.error(`Error disconnecting from store for ${cacheName}:`, err);
                 }
             }
         };

package/lib/support/RuntimeConfigurationManager.js

@@ -103,7 +103,8 @@ class RuntimeConfigurationManager {
             return {
                 metricsEnabled: cacheConfig?.metricsEnabled === true || cacheConfig?.metricsEnabled === 1 || false,
                 keyMetricsEnabled: cacheConfig?.keyMetricsEnabled === true || cacheConfig?.keyMetricsEnabled === 1 || false,
-                keyManagement
+                keyManagement,
+                throwOnErrors: this.options.throwOnErrors
             };
         } catch (error) {
             this.log.warn(`Failed to get runtime configuration for cache ${this.cacheName}:`, error);
@@ -114,7 +115,8 @@ class RuntimeConfigurationManager {
                     isUserAware: false,
                     isTenantAware: false,
                     isLocaleAware: false
-                }
+                },
+                throwOnErrors: this.options.throwOnErrors
             };
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cds-caching",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A caching plugin for SAP CAP applications",
   "repository": {
     "type": "git",
@@ -44,17 +44,18 @@
   ],
   "dependencies": {
     "@keyv/compress-gzip": "^2.0.3",
-    "@keyv/compress-lz4": "^1.0.0",
-    "@keyv/redis": "^4.5.0",
+    "@keyv/compress-lz4": "^1.0.1",
+    "@keyv/redis": "^5.0.0",
     "@keyv/sqlite": "^4.0.5",
-    "keyv": "^5.3.4"
+    "keyv": "^5.4.0"
   },
   "devDependencies": {
-    "eslint": "^9.30.1",
+    "@cap-js/cds-test": "^0.4.0",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "eslint": "^9.32.0",
     "husky": "^9.1.7",
-    "jest": "^30.0.4",
-    "release-it": "^19.0.3",
-    "@cap-js/cds-test": "^0.4.0"
+    "jest": "^30.0.5",
+    "release-it": "^19.0.4"
   },
   "engines": {
     "node": ">=20"