November 2022 Summaries

Managed services and serverless deployments have become increasingly popular in the software development process, shifting focus from infrastructure resources to application functionality and security. However, these managed services come with associated costs that can accumulate into unnecessary overhead expenses if not monitored. To mitigate these costs, it's essential to track resource consumption using observability, design resource-efficient APIs, follow best practices for writing APIs, refine infrastructure resource allocation, identify unused resources being deployed, and strategize for efficiency savings. Utilizing tools like Lumigo can help navigate complex environments, collect observable data, and perform automated cost optimization. By implementing these strategies, organizations can reduce unnecessary costs and optimize their cloud resource utilization.

AWS has made incremental improvements to Lambda's cold start performance over the past few years, but Java functions still often experience cold starts lasting several seconds, making them unsuitable for user-facing workloads. To address this, AWS has announced SnapStart, a feature that initializes a new Lambda execution environment and takes a snapshot of its memory and disk state during deployment, reducing cold start duration for Java functions. SnapStart can be enabled on a function through the AWS console or CLI, but it adds complexity as publishing a new version would take significantly longer due to additional steps. Despite these caveats, SnapStart offers significant performance improvements, with cold start durations reduced by over 50%. Lumigo supports SnapStart and provides visibility into its status for functions within their platform.

In this blog post, we explore the intricacies of distributed tracing in asynchronous systems, focusing on the challenges posed by message consumption APIs. We delve into the structure of traces and spans, discussing how instrumentation plays a crucial role in collecting these data points. The author highlights the importance of safe scopes for restoring trace context during iteration, emphasizing the limitations of built-in Python constructs like `__enter__` and `__exit__`. However, they propose an alternative approach by instrumenting the `__iter__` method of lists, providing a clean solution that works for many applications. The post concludes with a call to action, encouraging readers to try out the Lumigo OpenTelemetry Distro for Python, which offers a generous trial and free tier for those interested in distributed tracing.

The Lambda Telemetry API is a new local endpoint that allows Lambda extensions to receive telemetry data, including function logs, extension logs, events, metrics, and traces. It replaces the existing Logs API and provides backward compatibility. The API enables vendors to build better tools by giving them access to the Lambda execution environment, simplifying the process of forwarding logs to third-party log aggregation tools. The Telemetry API also provides additional features, such as detecting Lambda timeouts and auto-capturing them as CloudWatch metrics, which can be used to gain observability into complex serverless applications and troubleshoot issues.

Nov 08, 2022, is the publication date of an article discussing Amazon CloudWatch, a service that monitors AWS resources and can trigger alarms when metrics exceed certain thresholds. The author suggests using Lumigo to set up multiple CloudWatch Metric Alerts in less time than reading Amazon's documentation. Lumigo allows for easier setup of alerts with built-in integrations sending notifications to workflow tools without manual integration. The article creates an Amazon Lambda function that occasionally throws an error message and sets up a rule to run it periodically, creating a metric alert to notify when the error rate exceeds a specific threshold. The author demonstrates how to generate worlds and squirrels with AWS EventBridge, which triggers the Lambda on a regular schedule, and how to create a CloudWatch Metric Alert in Lumigo to send an email notification when the error rate spikes above a certain threshold.

With serverless and containerized applications becoming increasingly distributed, monitoring becomes more complicated due to siloed and incomplete telemetry. Distributed tracing brings great value by enabling end-to-end visibility in modern and complex applications, facilitating robust monitoring and tracking of processes at every stage to identify performance bottlenecks and failures, diagnose issues, and fix them. The importance of distributed tracing is undisputed, but many organizations struggle with deciding whether to build or buy a distributed tracing solution due to the complexity of implementing it from scratch. Distributed tracing has two approaches - agent-based and agentless - with agent-based tracing requiring installation of an agent on the system being monitored, potentially impacting performance, while agentless tracing uses unique identifiers for requests flowing through services without impacting performance. A good distributed tracing system should have characteristics such as accuracy, reliability, efficiency, compliance, and ease of use. Building a solution can be quick but hard to master, especially as complexity increases with service and team count growth. Buying a solution allows leveraging leading observability solutions without investing time and resources in building one from scratch, minimizing effort to achieve coverage of the distributed-tracing system. The cost of maintaining an in-house system is often underestimated due to difficulty measuring effort and time spent on developing and operating it, making procurement of a solution a challenge for many organizations. Ultimately, building or buying a monitoring tool depends on unique business needs, architectural complexity, and the expectation of needing customized monitoring for serverless applications.