Operations | Monitoring | ITSM | DevOps | Cloud

In part one of this series, we set up basic performance monitoring for our Fastify application using AppSignal and explored key performance indicators. Now that we have our monitoring foundation in place, it's time to leverage these insights to actively improve application performance. You'll learn how to detect performance regressions, find optimization opportunities, and implement custom instrumentation with OpenTelemetry.

In part one of this series, we learned how to implement batch updates and advanced inserts in Ecto to dramatically improve database performance. But implementing these optimizations is only the first step. Ensuring they continue to work effectively in production requires professional monitoring and observability. This guide will show you how to use AppSignal for Elixir to monitor your Ecto application's performance when dealing with batch data operations.

In the first two parts of this series, we introduced Angular Signals and built a reactive shopping cart. Our CartService already supports core operations like adding, removing, and clearing items, as well as computing total price and item count using computed(). All of this was done without touching RxJS, subscriptions, or change detection hacks. But a real-world cart does more than tally up numbers.

Last week, we were busy at AppSignal with our first-ever Launch Week and Rails World 2025! In case you missed it or spent the time snacking on our stroopwafels in Amsterdam, here's a quick recap of what we launched, and what that means for your monitoring setup!

GraphQL provides a powerful approach to building APIs, and Absinthe is the leading GraphQL implementation for Elixir applications. While GraphQL offers many benefits, it can introduce a set of errors and performance bottlenecks that might be challenging to track and debug. In this article, you’ll learn how to use AppSignal to monitor, debug, and resolve errors in your Absinthe-based GraphQL API.

Fastify stands out among Node.js web frameworks for its obsessive focus on performance and boasts impressive benchmarks, with throughput often 2-3x higher than Express and other popular alternatives. But here's the paradox: without proper visibility, even applications with a good foundation will degrade over time as you add features and complexity.

We're excited to officially launch our OpenTelemetry instrumentation. AppSignal is now able to expand our observability to a dozen popular languages, frameworks, and tools, giving customers the deep insights they need to monitor their entire stack. In this article, we'll show you how you can use AppSignal and OpenTelemetry to proactively monitor your app.

Background task processing is something that many developers may encounter when building Elixir applications. This might include sending emails asynchronously, posting and fetching data from an API, and more. Oban, a powerful and persistent job processing library, offers a reliable way to handle background tasks, scheduled operations, and more. However, like any complex system, Oban requires careful monitoring to ensure its smooth operation, identify bottlenecks, and prevent unexpected failures.

Over time, web applications have evolved from simple request/response-based systems into complex, distributed ones with lots of moving parts. If something goes wrong (and you can be sure it will), finding the cause can be nearly impossible. But this need not be the case: enter tracing. Tracing refers to the process of collecting detailed information about the execution of requests within an application, including function calls, execution time, and other relevant data.

In this guide, we'll harness AppSignal to detect, diagnose, and remove performance bottlenecks and employ proper tracing in a Ruby on Rails application. From setting up tracing to capturing errors and logging, we’ve got you covered. We'll ensure our application runs smoother than ever, even under the heaviest loads! But first, let's quickly touch on how to define tracing and its benefits.