@jzhuo3/dynamodb-lib 0.1.0 → 0.1.2

package/dist/cjs/index.js

@@ -356,6 +356,55 @@ function SetDelete(attribute, value) {
     const expression = `${path} :val0`;
     return new DynamoDBExpression(expressionAttributeNameMap, expressionAttributeValueMap, expression, 'DELETE');
 }
+function serializeExpressionValue(value, ancestors = new Set()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : { $type: 'Number', value: String(value) };
+    }
+    if (typeof value === 'bigint')
+        return { $type: 'BigInt', value: value.toString() };
+    if (value === undefined)
+        return { $type: 'Undefined' };
+    if (typeof value !== 'object') {
+        throw new TypeError(`Cannot describe expression value of type ${typeof value}`);
+    }
+    if (ancestors.has(value))
+        throw new TypeError('Cannot describe circular expression value');
+    ancestors.add(value);
+    try {
+        if (value instanceof lib_dynamodb_1.NumberValue)
+            return { $type: 'NumberValue', value: value.toString() };
+        if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+            const bytes = value instanceof ArrayBuffer
+                ? Buffer.from(value)
+                : Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+            return { $type: 'Binary', encoding: 'base64', value: bytes.toString('base64') };
+        }
+        if (value instanceof Set) {
+            return { $type: 'Set', values: Array.from(value, item => serializeExpressionValue(item, ancestors)) };
+        }
+        if (Array.isArray(value))
+            return Array.from(value, item => serializeExpressionValue(item, ancestors));
+        if (value instanceof Map) {
+            return { $type: 'Map', entries: Array.from(value, ([key, item]) => [
+                    serializeExpressionValue(key, ancestors), serializeExpressionValue(item, ancestors),
+                ]) };
+        }
+        if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+            throw new TypeError('Cannot describe unsupported expression value object');
+        }
+        if (Object.getOwnPropertySymbols(value).some(key => Object.prototype.propertyIsEnumerable.call(value, key))) {
+            throw new TypeError('Cannot describe expression value with symbol keys');
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key, serializeExpressionValue(item, ancestors),
+        ]));
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
 class DynamoDBExpression {
     expressionAttributeNameMap;
     expressionAttributeValueMap;
@@ -369,6 +418,27 @@ class DynamoDBExpression {
         this.expression = expression;
         this.updateExpressionGroup = updateExpressionGroup;
     }
+    /**
+     * Detached, JSON-serializable description of the expression. Intended for logging,
+     * debugging, and unit tests that need to assert on a built expression
+     * without reaching into the internal Maps.
+     * Sets, bigint, binary, Maps, NumberValue, undefined and non-finite numbers
+     * use explicit `$type` tags. Circular and unsupported values throw TypeError.
+     */
+    describe() {
+        return {
+            expression: this.expression,
+            expressionAttributeNames: Object.fromEntries(this.expressionAttributeNameMap),
+            expressionAttributeValues: this.expressionAttributeValueMap
+                ? Object.fromEntries(Array.from(this.expressionAttributeValueMap, ([key, value]) => [
+                    key, serializeExpressionValue(value),
+                ]))
+                : {},
+            ...(this.updateExpressionGroup !== undefined
+                ? { updateExpressionGroup: this.updateExpressionGroup }
+                : {}),
+        };
+    }
 }
 exports.DynamoDBExpression = DynamoDBExpression;
 var DynamoDBTransactionMode;
@@ -421,6 +491,7 @@ class DynamoDBTransaction {
                     if (i === retries - 1) {
                         throw error;
                     }
+                    this.logger.warn('DynamoDB retrying transaction conflict', { mode: this.mode, attempt: i + 1, maxAttempts: retries, delayMs: delay * (i + 1) });
                     await new Promise(resolve => setTimeout(resolve, delay * (i + 1)));
                 }
                 else {
@@ -669,10 +740,6 @@ class DynamoDBTransaction {
             }
             ExpressionAttributeValues[attributeValueVariable] = value;
         });
-        this.logger.debug('Update Expression: %s', UpdateExpression);
-        this.logger.debug('Condition Expression: %s', ConditionExpression);
-        this.logger.debug('Expression Attribute Names: %o', ExpressionAttributeNames);
-        this.logger.debug('Expression Attribute Values: %o', ExpressionAttributeValues);
         this.transactWriteItems.push({
             Update: {
                 TableName: table.name,
@@ -748,6 +815,7 @@ class DynamoDBTransaction {
         const result = {
             numberOfTransactItems: 0,
         };
+        this.logger.debug('DynamoDB transaction started', { mode: this.mode, itemCount: this.mode === DynamoDBTransactionMode.READ ? this.transactGetItems.length : this.transactWriteItems.length });
         switch (this.mode) {
             case DynamoDBTransactionMode.READ:
                 command = new lib_dynamodb_1.TransactGetCommand({
@@ -759,21 +827,21 @@ class DynamoDBTransaction {
                 const { Responses } = (await this.txConflictRetryWrapper(command, this.txRetryLimit, this.txRetryDelay).catch((e) => {
                     this._cleanup();
                     if (isTransactionConflictError(e)) {
-                        this.logger.error('Transaction conflict due to TransactionConflict');
+                        this.logger.error('DynamoDB transaction conflict retry limit reached', { errorName: e.name });
                         throw new DynamoDBError(409, {
                             message: e.message,
                             cause: e,
                         });
                     }
                     else if (e.name === 'TransactionCanceledException') {
-                        this.logger.error(e.message);
+                        this.logger.error('DynamoDB transaction canceled', { errorName: e.name });
                         throw new DynamoDBError(400, {
                             message: e.message,
                             cause: e,
                         });
                     }
                     else {
-                        this.logger.error('Transaction failed due to %s', e.message);
+                        this.logger.error('Transaction failed', { errorName: e.name });
                         throw new DynamoDBError(500, {
                             message: e.message,
                             cause: e,
@@ -822,28 +890,28 @@ class DynamoDBTransaction {
                 await this.txConflictRetryWrapper(command, this.txRetryLimit, this.txRetryDelay).catch((e) => {
                     this._cleanup();
                     if (isTransactionConflictError(e)) {
-                        this.logger.error('Transaction conflict due to TransactionConflict');
+                        this.logger.error('DynamoDB transaction conflict retry limit reached', { errorName: e.name });
                         throw new DynamoDBError(409, {
                             message: e.message,
                             cause: e,
                         });
                     }
                     else if (e.name === 'TransactionCanceledException') {
-                        this.logger.error(e.message);
+                        this.logger.error('DynamoDB transaction canceled', { errorName: e.name });
                         throw new DynamoDBError(400, {
                             message: e.message,
                             cause: e,
                         });
                     }
                     else if (e.name === 'ValidationException') {
-                        this.logger.error('The request parameters are invalid with error: %s', e.message);
+                        this.logger.error('The request parameters are invalid', { errorName: e.name });
                         throw new DynamoDBError(400, {
                             message: 'Invalid request parameters',
                             cause: e,
                         });
                     }
                     else {
-                        this.logger.error('Transaction failed due to %s', e.message);
+                        this.logger.error('Transaction failed', { errorName: e.name });
                         throw new DynamoDBError(500, {
                             message: e.message,
                             cause: e,
@@ -856,6 +924,7 @@ class DynamoDBTransaction {
             default:
                 throw new Error('Invalid transaction mode');
         }
+        this.logger.debug('DynamoDB transaction completed', { mode: this.mode, itemCount: result.numberOfTransactItems });
         return result;
     }
 }
@@ -925,8 +994,7 @@ class DynamoDBService {
                 ExpressionAttributeNames[attributeNameVariable] = attributeName;
             });
         }
-        this.logger.debug('Projection Expression: %s', ProjectionExpression);
-        this.logger.debug('Expression Attribute Names: %o', ExpressionAttributeNames);
+        this.logger.debug('DynamoDB request started', { operation: 'getOne', tableKey });
         const getCommand = new lib_dynamodb_1.GetCommand({
             TableName: table.name,
             Key: keys,
@@ -941,22 +1009,14 @@ class DynamoDBService {
             .send(getCommand)
             .catch((e) => {
             if (e.name === 'ValidationException') {
-                this.logger.error('The request parameters are invalid with error: %s', e.message, {
-                    tableKey,
-                    primaryKey,
-                    opts,
-                });
+                this.logger.error('The request parameters are invalid', { errorName: e.name, tableKey });
                 throw new DynamoDBError(400, {
                     message: 'Invalid request parameters',
                     cause: e,
                 });
             }
             else {
-                this.logger.error('Failed to get item with error: %s', e.message, {
-                    tableKey,
-                    primaryKey,
-                    opts,
-                });
+                this.logger.error('Failed to get item', { errorName: e.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to get item',
                     cause: e,
@@ -967,6 +1027,7 @@ class DynamoDBService {
         if (item && table.timeToLiveAttribute && item[table.timeToLiveAttribute] !== undefined) {
             const now = getUnixTime(new Date());
             if (item[table.timeToLiveAttribute] <= now) {
+                this.logger.debug('DynamoDB getOne completed', { tableKey, outcome: 'expired' });
                 return null;
             }
             // Delete the time to live attribute from the item if not requested
@@ -974,6 +1035,7 @@ class DynamoDBService {
                 delete item[table.timeToLiveAttribute];
             }
         }
+        this.logger.debug('DynamoDB getOne completed', { tableKey, outcome: item ? 'found' : 'not-found' });
         // Item will be undefined if not found
         // Convert keys back to camelCase if camelOrSnake is 'camel' or to snake_case if camelOrSnake is 'snake'
         if (item) {
@@ -1007,7 +1069,6 @@ class DynamoDBService {
         const keys = primaryKeys.map((primaryKey, indx) => {
             const isArrayOfKeys = Array.isArray(primaryKey);
             const pkStr = serializeKey(primaryKey);
-            this.logger.debug('Primary Key: %s', pkStr);
             if (pkIndexMap.has(pkStr)) {
                 throw new Error(`Duplicate primary key: ${pkStr}`);
             }
@@ -1056,13 +1117,12 @@ class DynamoDBService {
                 ExpressionAttributeNames[attributeNameVariable] = attributeName;
             });
         }
-        this.logger.debug('Projection Expression: %s', ProjectionExpression);
-        this.logger.debug('Expression Attribute Names: %o', ExpressionAttributeNames);
         const results = new Array(primaryKeys.length).fill(null);
         const now = getUnixTime(new Date());
         let unprocessedAttempt = 0;
         while (keys.length > 0) {
             const batch = keys.splice(0, 100);
+            this.logger.debug('DynamoDB batch request started', { operation: 'getMany', tableKey, itemCount: batch.length });
             const batchGetCommand = new lib_dynamodb_1.BatchGetCommand({
                 RequestItems: {
                     [table.name]: {
@@ -1076,19 +1136,23 @@ class DynamoDBService {
                 },
                 ReturnConsumedCapacity: opts.returnConsumedCapacity ?? client_dynamodb_1.ReturnConsumedCapacity.NONE,
             });
-            const { Responses: responses, UnprocessedKeys: rawUnprocessedKeys } = await this.ddbDocClient.send(batchGetCommand);
+            const { Responses: responses, UnprocessedKeys: rawUnprocessedKeys } = await this.ddbDocClient.send(batchGetCommand).catch((error) => {
+                this.logger.error('Failed to get items', { tableKey, errorName: error.name });
+                throw error;
+            });
             const items = responses && responses[table.name] ? responses[table.name] : [];
             const unprocessedKeys = (rawUnprocessedKeys && rawUnprocessedKeys[table.name]?.Keys) || [];
-            this.logger.debug(`GetMany Responsed Items: %o`, items);
-            this.logger.debug('Now: %d', now);
             if (unprocessedKeys.length > 0) {
                 if (unprocessedAttempt >= MAX_UNPROCESSED_ATTEMPTS) {
+                    this.logger.error('DynamoDB batch retry limit reached', { operation: 'getMany', tableKey, retryCount: unprocessedAttempt });
                     throw new DynamoDBError(500, {
                         message: 'Failed to retrieve items after multiple attempts',
                         cause: new Error('Too many unprocessed items'),
                     });
                 }
-                await sleep(backoffDelayMs(unprocessedAttempt));
+                const delayMs = backoffDelayMs(unprocessedAttempt);
+                this.logger.warn('DynamoDB retrying unprocessed batch items', { operation: 'getMany', tableKey, itemCount: unprocessedKeys.length, attempt: unprocessedAttempt + 1, delayMs });
+                await sleep(delayMs);
                 unprocessedAttempt += 1;
             }
             else {
@@ -1111,7 +1175,6 @@ class DynamoDBService {
                 const pkStr = serializeKey(table.sortKey
                     ? [item[table.partitionKey], item[table.sortKey]]
                     : item[table.partitionKey]);
-                this.logger.debug('Primary Key: %s', pkStr);
                 //  Delete the primary key values from the item if not requested
                 if (optIncludePartitionKey === false) {
                     delete item[table.partitionKey];
@@ -1138,6 +1201,7 @@ class DynamoDBService {
                 }
             });
         }
+        this.logger.debug('DynamoDB getMany completed', { tableKey, requestedCount: primaryKeys.length, returnedCount: results.filter(item => item !== null).length });
         return results;
     }
     async find(tableKey, keyCondition, filter = null, opts = {}, camelOrSnake = 'camel') {
@@ -1300,7 +1364,6 @@ class DynamoDBService {
                             indexName: indexToScan.indexName,
                             projectionType: indexToScan
                                 .projectionType,
-                            projectionFields,
                         });
                     }
                     break;
@@ -1330,12 +1393,11 @@ class DynamoDBService {
                             ]).length > 0;
                     }
                     if (hasFieldNotInsideGSIProjection) {
-                        this.logger.error('Some of the projection fields are not included in the GSI projection, which may cause additional read cost', {
+                        this.logger.error('Some of the projection fields are not included in the GSI projection, so the query cannot be executed', {
                             tableKey,
                             indexName: indexToScan.indexName,
                             projectionType: indexToScan
                                 .projectionType,
-                            projectionFields,
                         });
                         throw new Error('All projection fields must be included in the GSI projection');
                     }
@@ -1392,11 +1454,6 @@ class DynamoDBService {
             }
             ExpressionAttributeValues[attributeValueVariable] = value;
         });
-        this.logger.debug('Projection Expression: %s', ProjectionExpression);
-        this.logger.debug('Expression Attribute Names: %o', ExpressionAttributeNames);
-        this.logger.debug('Expression Attribute Values: %o', ExpressionAttributeValues);
-        this.logger.debug('Key Condition Expression: %s', KeyConditionExpression);
-        this.logger.debug('Filter Expression: %s', FilterExpression);
         const numOfNeededItems = opts.limit; // May be undefined then no limit
         const result = {
             items: [],
@@ -1458,32 +1515,24 @@ class DynamoDBService {
                 : {}),
         };
         while (true) {
+            this.logger.debug('DynamoDB query page requested', { tableKey, hasCursor: !!params.ExclusiveStartKey, hasFilter: !!params.FilterExpression });
             const { Items, LastEvaluatedKey } = await this.ddbDocClient
                 .send(new lib_dynamodb_1.QueryCommand(params))
                 .catch((e) => {
                 if (e.name === 'ValidationException') {
-                    this.logger.error('The request parameters are invalid with error: %s', e.message, {
-                        tableKey,
-                        keyCondition,
-                        filter,
-                        opts,
-                    });
+                    this.logger.error('The request parameters are invalid', { errorName: e.name, tableKey });
                     throw new DynamoDBError(400, {
                         message: 'Invalid request parameters',
                         cause: e,
                     });
                 }
-                this.logger.error('Failed to query items with error: %s', e.message, {
-                    tableKey,
-                    keyCondition,
-                    filter,
-                    opts,
-                });
+                this.logger.error('Failed to query items', { errorName: e.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to query items',
                     cause: e,
                 });
             });
+            this.logger.debug('DynamoDB query page received', { tableKey, itemCount: Items?.length ?? 0, hasMore: !!LastEvaluatedKey });
             if (LastEvaluatedKey) {
                 params.ExclusiveStartKey = LastEvaluatedKey;
             }
@@ -1628,6 +1677,7 @@ class DynamoDBService {
                 ExpressionAttributeNames[key] = value;
             });
         }
+        this.logger.debug('DynamoDB request started', { operation: 'createOne', tableKey });
         const putCommand = new lib_dynamodb_1.PutCommand({
             TableName: table.name,
             Item: normalizedItem,
@@ -1680,22 +1730,18 @@ class DynamoDBService {
             const error = e;
             if (error.name === 'ConditionalCheckFailedException' &&
                 opts.onConflict === 'ignore') {
-                this.logger.debug('Item %s already exists', normalizedItem[table.partitionKey] +
-                    (table.sortKey ? `:${normalizedItem[table.sortKey]}` : ''));
+                this.logger.debug('DynamoDB create skipped: item already exists', { tableKey });
                 result.created = false;
             }
             else {
-                this.logger.error('Failed to create item with error: %s', error.message, {
-                    tableKey,
-                    item: normalizedItem,
-                    opts,
-                });
+                this.logger.error('Failed to create item', { errorName: error.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to create item',
                     cause: error,
                 });
             }
         }
+        this.logger.debug('DynamoDB createOne completed', { tableKey, created: result.created });
         return result;
     }
     async createMany(tableKey, primaryKeys, items, opts = {}) {
@@ -1740,6 +1786,7 @@ class DynamoDBService {
         let unprocessedAttempt = 0;
         while (normalizedItems.length > 0) {
             const batch = normalizedItems.splice(0, 25);
+            this.logger.debug('DynamoDB batch request started', { operation: 'createMany', tableKey, itemCount: batch.length });
             const batchWriteCommand = new lib_dynamodb_1.BatchWriteCommand({
                 RequestItems: {
                     [table.name]: batch.map(item => ({
@@ -1753,11 +1800,7 @@ class DynamoDBService {
             const { UnprocessedItems } = await this.ddbDocClient
                 .send(batchWriteCommand)
                 .catch((e) => {
-                this.logger.error('Failed to create items with error: %s', e.message, {
-                    tableKey,
-                    items: batch,
-                    opts,
-                });
+                this.logger.error('Failed to create items', { errorName: e.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to create items',
                     cause: e,
@@ -1766,12 +1809,15 @@ class DynamoDBService {
             const unprocessedItems = UnprocessedItems?.[table.name];
             if (unprocessedItems !== undefined && unprocessedItems.length > 0) {
                 if (unprocessedAttempt >= MAX_UNPROCESSED_ATTEMPTS) {
+                    this.logger.error('DynamoDB batch retry limit reached', { operation: 'createMany', tableKey, retryCount: unprocessedAttempt });
                     throw new DynamoDBError(500, {
                         message: 'Failed to create items after multiple attempts',
                         cause: new Error('Too many unprocessed items'),
                     });
                 }
-                await sleep(backoffDelayMs(unprocessedAttempt));
+                const delayMs = backoffDelayMs(unprocessedAttempt);
+                this.logger.warn('DynamoDB retrying unprocessed batch items', { operation: 'createMany', tableKey, itemCount: unprocessedItems.length, attempt: unprocessedAttempt + 1, delayMs });
+                await sleep(delayMs);
                 unprocessedAttempt += 1;
                 normalizedItems.push(...unprocessedItems
                     .map(item => item.PutRequest?.Item)
@@ -1781,6 +1827,7 @@ class DynamoDBService {
                 unprocessedAttempt = 0;
             }
         }
+        this.logger.debug('DynamoDB createMany completed', { tableKey, itemCount: result.numberOfItems });
         return result;
     }
     async update(tableKey, primaryKey, commands, condition = null, opts = {}, camelOrSnake = 'camel') {
@@ -1856,10 +1903,7 @@ class DynamoDBService {
             }
             ExpressionAttributeValues[attributeValueVariable] = value;
         });
-        this.logger.debug('Update Expression: %s', UpdateExpression);
-        this.logger.debug('Condition Expression: %s', ConditionExpression);
-        this.logger.debug('Expression Attribute Names: %o', ExpressionAttributeNames);
-        this.logger.debug('Expression Attribute Values: %o', ExpressionAttributeValues);
+        this.logger.debug('DynamoDB request started', { operation: 'update', tableKey });
         const updateCommand = new lib_dynamodb_1.UpdateCommand({
             TableName: table.name,
             Key: keys,
@@ -1893,29 +1937,17 @@ class DynamoDBService {
         catch (e) {
             const error = e;
             if (error.name === 'ValidationException') {
-                this.logger.error('The request parameters are invalid with error: %s', error.message, {
-                    tableKey,
-                    primaryKey,
-                    commands,
-                    condition,
-                    opts,
-                });
+                this.logger.error('The request parameters are invalid', { errorName: error.name, tableKey });
                 throw new DynamoDBError(400, {
                     message: 'Invalid request parameters',
                     cause: e,
                 });
             }
             else if (error.name === 'ConditionalCheckFailedException') {
-                this.logger.debug('Condition failed to update item %s', primaryKey.toString());
+                this.logger.debug('DynamoDB update skipped: condition not met', { tableKey });
             }
             else {
-                this.logger.error('Failed to update item with error: %s', error.message, {
-                    tableKey,
-                    primaryKey,
-                    commands,
-                    condition,
-                    opts,
-                });
+                this.logger.error('Failed to update item', { errorName: error.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to update item',
                     cause: e,
@@ -1941,6 +1973,7 @@ class DynamoDBService {
                 result.item = newItem;
             }
         }
+        this.logger.debug('DynamoDB update completed', { tableKey, updatedOrCreated: result.updatedOrCreated });
         return result;
     }
     async deleteOne(tableKey, primaryKey, condition = null, opts = {}, camelOrSnake = 'camel') {
@@ -1976,6 +2009,7 @@ class DynamoDBService {
             }
             ConditionExpression = condition.expression;
         }
+        this.logger.debug('DynamoDB request started', { operation: 'deleteOne', tableKey });
         const deleteCommand = new lib_dynamodb_1.DeleteCommand({
             TableName: table.name,
             Key: keys,
@@ -2003,27 +2037,17 @@ class DynamoDBService {
         catch (e) {
             const error = e;
             if (error.name === 'ValidationException') {
-                this.logger.error('The request parameters are invalid with error: %s', error.message, {
-                    tableKey,
-                    primaryKey,
-                    condition,
-                    opts,
-                });
+                this.logger.error('The request parameters are invalid', { errorName: error.name, tableKey });
                 throw new DynamoDBError(400, {
                     message: 'Invalid request parameters',
                     cause: e,
                 });
             }
             else if (error.name === 'ConditionalCheckFailedException') {
-                this.logger.debug('Condition failed to delete item %s', primaryKey.toString());
+                this.logger.debug('DynamoDB delete skipped: condition not met', { tableKey });
             }
             else {
-                this.logger.error('Failed to delete item with error: %s', error.message, {
-                    tableKey,
-                    primaryKey,
-                    condition,
-                    opts,
-                });
+                this.logger.error('Failed to delete item', { errorName: error.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to delete item',
                     cause: e,
@@ -2049,6 +2073,7 @@ class DynamoDBService {
                 result.item = newItem;
             }
         }
+        this.logger.debug('DynamoDB deleteOne completed', { tableKey, deleted: result.deleted });
         return result;
     }
     async deleteMany(tableKey, primaryKeys, opts = {}) {
@@ -2073,6 +2098,7 @@ class DynamoDBService {
         let unprocessedAttempt = 0;
         while (keys.length > 0) {
             const batch = keys.splice(0, 25);
+            this.logger.debug('DynamoDB batch request started', { operation: 'deleteMany', tableKey, itemCount: batch.length });
             const batchWriteCommand = new lib_dynamodb_1.BatchWriteCommand({
                 RequestItems: {
                     [table.name]: batch.map(key => ({
@@ -2086,11 +2112,7 @@ class DynamoDBService {
             const { UnprocessedItems } = await this.ddbDocClient
                 .send(batchWriteCommand)
                 .catch((e) => {
-                this.logger.error('Failed to delete items with error: %s', e.message, {
-                    tableKey,
-                    keys: batch,
-                    opts,
-                });
+                this.logger.error('Failed to delete items', { errorName: e.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to delete items',
                     cause: e,
@@ -2099,12 +2121,15 @@ class DynamoDBService {
             const unprocessedItems = UnprocessedItems?.[table.name];
             if (unprocessedItems !== undefined && unprocessedItems.length > 0) {
                 if (unprocessedAttempt >= MAX_UNPROCESSED_ATTEMPTS) {
+                    this.logger.error('DynamoDB batch retry limit reached', { operation: 'deleteMany', tableKey, retryCount: unprocessedAttempt });
                     throw new DynamoDBError(500, {
                         message: 'Failed to delete items after multiple attempts',
                         cause: new Error('Too many unprocessed items'),
                     });
                 }
-                await sleep(backoffDelayMs(unprocessedAttempt));
+                const delayMs = backoffDelayMs(unprocessedAttempt);
+                this.logger.warn('DynamoDB retrying unprocessed batch items', { operation: 'deleteMany', tableKey, itemCount: unprocessedItems.length, attempt: unprocessedAttempt + 1, delayMs });
+                await sleep(delayMs);
                 unprocessedAttempt += 1;
                 keys.push(...unprocessedItems
                     .map(item => item.DeleteRequest?.Key)
@@ -2114,6 +2139,7 @@ class DynamoDBService {
                 unprocessedAttempt = 0;
             }
         }
+        this.logger.debug('DynamoDB deleteMany completed', { tableKey, itemCount: result.numberOfItems });
         return result;
     }
     transaction(opts) {