Feature request: Allow customizing ApiGatewayResolver serializer instantiation parameters

[alexminza]

Use case

By default json.dumps is initialized with ensure_ascii: bool = True which escapes all non-ASCII output.
To overcome this, one has to recreate the internal serializer from scratch and pass it as a custom serializer:

serializer = functools.partial(json.dumps, separators=(",", ":"), cls=json_encoder.Encoder, ensure_ascii=False)
app = APIGatewayHttpResolver(serializer=serializer)

This hardcodes many of the library design choices on the app side.

Solution/User Experience

Allow passing additional parameters to the serializer initialization:

app = APIGatewayHttpResolver(serializer_kwargs={'ensure_ascii': False})

https://github.com/aws-powertools/powertools-lambda-python/blob/develop/aws_lambda_powertools/event_handler/api_gateway.py#L1553

def __init__(self, serializer_kwargs: dict):
    # Allow for a custom serializer or a concise json serialization
    self._serializer = serializer or partial(json.dumps, separators=(",", ":"), cls=Encoder, **serializer_kwargs)

Proposed solution is similar to the LangChain library design:
https://api.python.langchain.com/en/latest/chains/langchain.chains.llm.LLMChain.html#langchain.chains.llm.LLMChain.llm_kwargs

Alternative solutions

Hardcode serializer args:

self._serializer = serializer or partial(json.dumps, separators=(",", ":"), cls=Encoder, ensure_ascii=False)

Acknowledgment

• This feature request meets Powertools for AWS Lambda (Python) Tenets
• Should this be considered in other Powertools for AWS Lambda languages? i.e. Java, TypeScript, and .NET

[boring-cyborg]

Thanks for opening your first issue here! We'll come back to you as soon as we can.
In the meantime, check out the #python channel on our Powertools for AWS Lambda Discord: Invite link

[leandrodamascena]

Hey @alexminza! Thanks for opening this! I see your point here, but since we already provide a way for customers to bring their own serializer, don't you think allowing kwargs in the default serializer might complicate the overall experience? Additionally, we may lose control of the default serializer and customers may make mistakes unintentionally.

To overcome this, one has to recreate the internal serializer from scratch and pass it as a custom serializer:

Exactly! That’s the core idea behind allowing custom serializers: to give customers the flexibility to bring their own implementation with any configuration they need.

Is there any case where a custom serializer is not enough in your workload?

[alexminza]

This is how the custom serializer for the described used case would be instantiated:

serializer = functools.partial(json.dumps, separators=(",", ":"), cls=json_encoder.Encoder, ensure_ascii=False)

This is basically copy/pasting the code from ApiGatewayResolver.__init__ just to add the ensure_ascii parameter:
https://github.com/aws-powertools/powertools-lambda-python/blob/develop/aws_lambda_powertools/event_handler/api_gateway.py#L1553

# Allow for a custom serializer or a concise json serialization
self._serializer = serializer or partial(json.dumps, separators=(",", ":"), cls=Encoder)

The initial suggestion was to avoid hardcoding serializer instantiation on the developer side - because we do not need a whole new custom serializer but just to adapt and configure the default one. I would not want to take full responsibility of a whole custom serializer but just to adapt the way the default serializer works.

[leandrodamascena]

Thanks for sharing your thoughts and adding more details, @alexminza! I completely understand your perspective, but I wanted to clarify that we already provide a way for customers to use a custom serializer - even in your case it means leveraging 80% of our existing code and simply adding an additional parameter.

When we build a new utility/feature in Powertools, we make some design decisions to keep the codebase clean and focused, but we recognize that customers may have unique use cases. This is exactly why we make it flexible for users to bring their own custom serializer and address custom use cases.

I still feel that introducing a new parameter like serializer_kwargs could complicate the user experience. Keeping it simple with just custom_serializer allows customers to bring whatever they need without adding extra layers of complexity.

I'm going to close this issue as not planned now and please feel free to reopen it if you want to tell us any additional information.

[github-actions]

⚠️COMMENT VISIBILITY WARNING⚠️

This issue is now closed. Please be mindful that future comments are hard for our team to see.

If you need more assistance, please either tag a team member or open a new issue that references this one.

If you wish to keep having a conversation with other community members under this issue feel free to do so.