Putting item in dynamo failing with no error thrown (AWS SDK v3)

So I'm currently working on an AWS lambda that, amongst several different things, has the responsibility to put items into a dynamoDb table. I have all the permissions setup in the SAM template (short example below)

 - Effect: "Allow"
        Action:
           - "dynamodb:GetItem"
           - "dynamodb:PutItem"
           - "dynamodb:UpdateItem"
           - "dynamodb:DeleteItem"
        Resource:
         - !Join ["/", [!Sub "arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table", '{{resolve:ssm:/examples/example/tableName}}'] ]

My logic to call the table and put the item is the following

dynamoStorage.ts

export const setThings = async (accountId: string, clientKey: string, things: EnhancedSearchFilter[]): Promise<void> => {
    if (!tableName) {
        return Promise.reject(new Error(DynamoError.InvalidTableName));
    }
    // send all the things over to dynamo
    const promises = things.map((thing) => putThing(accountId, clientKey, thing));
    return Promise.allSettled(promises).then((results) => {
        if (results.some((result) => result.status === 'rejected')) {
            customLogger.error('Failed to put things', { clientKey, things });
            throw new Error('Failed to set all filters');
        }
    });
};

putThing function calling dynamo

export const putThing = async (accountId: string, clientKey: string, thing: EnhancedThing): Promise<void> => {

    if (!tableName) {
        return Promise.reject(new Error(DynamoError.InvalidTableName));
    }

    const thingRef = createThingRef(accountId, thing.id);
    const params: PutCommandInput = {
        Item: thingToItem(clientKey, accountId, thing),
        TableName: tableName
    };

    try {
        await dynamoClient.send(new PutCommand(params));
        return Promise.resolve();
    } catch (cause) {
        customLogger.error('Failed to put thing', { clientKey, thingRef, cause });
        throw new Error(`Failed to put thing`, { cause });
    }
};

In cloudwatch I can see this customLogger.error('Failed to put thing', { clientKey, thingRef, cause }); quite a few times but the cause is displayed as an empty object {}

My question is, am I doing the error handling wrong in this scenario, and if so, how can I improve, or if it is right, why on earth is dynamo failing giving no error back?

Thanks

> My question is, am I doing the error handling wrong in this scenario, and if so, how can I improve, or if it is right, why on earth is dynamo failing giving no error back?

Because you are using Promise.allSettled, the error message (or the reason of the error), is returned in each item of the array results, if you inspect the result of this part:

return Promise.allSettled(promises).then((results) => {
    //                👇👇👇 this `result` object have a `result.reason` property
    if (results.some((result) => result.status === 'rejected')) {
        customLogger.error('Failed to put things', { clientKey, things });
        throw new Error('Failed to set all filters');
    }
});

You can find the error message of that specific promise. The Promise.allSettled doesn't handle the error message. You need to inspect each promise for its own error.

You can check the MDN documentation of this Promise API: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled

In that part of the code in your snippet, you are hiding the error/swallowing the error returned by DynamoDB.

You will need to change the if / lookup you do to the rejected state. You can use a Array.find, for example.

Batch writing to DynamoDB

Another suggestion here, is to explore the BatchWriteItemCommand from DynamoDB SDK v3:

• https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-dynamodb/classes/batchwriteitemcommand.html

• https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/dynamodb-example-table-read-write-batch.html (this is using V2, but you can have an idea/play with it)

The code pattern you are using: "Create an array of PutItem promises and wait for all of them to resolve."

It can create bottlenecks or be throttled by DynamoDB, depending on the size x number of items and how your table is configured (On-demand x Provisioned Capacity).

With a single call to BatchWriteItem, you can transmit up to 16MB of data over the network, consisting of up to 25 items put or delete operations.

You may need to measure it, but it can improve your application performance. Reducing memory and time in the lambda, instead of N promises call, you have a single call and waiting for a network response from DynamoDB. Instead of N promises calls, you send a list of actions, and DynamoDB handles the write on their side)