Monitor your Elixir application with OpenTelemetry and SigNoz 🚀

This tutorial was initially posted on SigNoz Blog and is written by Ricardo Paiva

OpenTelemetry can be utilized to instrument your Elixir purposes to generate telemetry knowledge. The telemetry knowledge can then be visualized utilizing an observability device to watch your Elixir utility efficiency. On this tutorial, we are going to use OpenTelemetry Elixir libraries to instrument an Elixir utility after which visualize it utilizing SigNoz.

Someplace throughout the lifetime of an utility, it is inevitable that it’s going to have some efficiency points. You probably have arrange observability to your purposes, it could possibly assist you determine these efficiency points rapidly.



Introduction

For cloud-native purposes, OpenTelemetry supplies a framework to arrange observability. It consists of a set of instruments, APIs, and SDKs that you should use to instrument, generate, gather, and export telemetry knowledge for evaluation so as to perceive your software program’s efficiency and conduct.

On this tutorial, we’ll present you the right way to monitor your Elixir utility utilizing OpenTelemetry and Signoz. We’ll give attention to the commonest and fundamental Elixir combo: Phoenix + Ecto.

As soon as every part is put in and configured, you’ll see how a lot time your endpoints and database operations are taking. The collected knowledge, when visualized by a backend device like SigNoz will allow you to to troubleshot issues, determine bottlenecks and in addition discover utilization patterns that may allow you to enhance your utility pro-actively.



OpenTelemetry and SigNoz

OpenTelemetry libraries can solely allow the era of telemetry knowledge. You want a backend that takes within the knowledge for storage and visualization. SigNoz is a full-stack open-source APM device that can be utilized for storing and visualizing the telemetry knowledge collected with OpenTelemetry. It’s constructed natively on OpenTelemetry and works on the OTLP knowledge codecs.

SigNoz supplies question and visualization capabilities for the end-user and comes with out-of-box charts for utility metrics and traces.

Now let’s get all the way down to the right way to implement OpenTelemetry in your Elixir utility.



Putting in SigNoz

First, it’s good to set up SigNoz in order that OpenTelemetry can ship the info to it.

SigNoz may be put in on macOS or Linux computer systems in simply three steps through the use of a easy set up script.

The set up script routinely installs Docker Engine on Linux. Nevertheless, on macOS, you have to manually set up Docker Engine earlier than working the set up script.

git clone -b major https://github.com/SigNoz/signoz.git
cd signoz/deploy/
./set up.sh
Enter fullscreen mode

Exit fullscreen mode

You possibly can go to our documentation for directions on the right way to set up SigNoz utilizing Docker Swarm and Helm Charts.

If you end up achieved putting in SigNoz, you possibly can entry the UI at http://localhost:3301



Instrumenting an Elixir Phoenix utility with OpenTelemetry

We’ll give attention to instrumenting one of the crucial widespread combos of the Elixir world: Phoenix + Ecto.

Step 1: Add the required dependencies

Step one to instrument your Elixir utility with OpenTelemetry is so as to add the required dependencies to your combine.exs file and fetch them with combine deps.get

{:opentelemetry, "~> 1.0.3"},
{:opentelemetry_exporter, "~> 1.0.3"},
{:opentelemetry_phoenix, "~> 1.0.0"},
{:opentelemetry_ecto, "~> 1.0.0"}
Enter fullscreen mode

Exit fullscreen mode

Step 2: Configure the Elixir utility to export telemetry knowledge

Then we have to configure our utility to export telemetry knowledge. There are two issues that it’s good to set:

  • YOUR_APP_NAME
    You possibly can put your utility or service title right here for identification.
  • OTEL Collector endpoint
    The OTEL collector comes bundled with SigNoz set up. Since, we put in SigNoz on our native machine, the endpoint is http://localhost:4318.
config :opentelemetry, :useful resource, service: %{title: "YOUR_APP_NAME"}

config :opentelemetry, :processors,
  otel_batch_processor: %{
    exporter: {
      :opentelemetry_exporter,
      %{endpoints: ["http://localhost:4318"]}
    }
  }
Enter fullscreen mode

Exit fullscreen mode

Step 3: Initialize telemetry handlers

As it’s documented within the opentelemetry_phoenix and opentelemetry_ecto hexdocs.pm pages, we have to initialize each telemetry handlers.

OpentelemetryPhoenix.setup()
OpentelemetryEcto.setup([:your_app_name, :repo])
Enter fullscreen mode

Exit fullscreen mode

:your_app_name needs to be changed by your app title and congratulations, you’ve gotten instrumented your utility with OpenTelemetry.



Monitor your Elixir utility with Signoz

Now you can monitor your Elixir utility with SigNoz. Whether or not you’re utilizing a Phoenix to create REST APIs or HTML purposes, it’s good to generate some knowledge by interacting along with your utility.

On this GitHub repository you’ll discover an Elixir Phoenix API that exposes a few endpoints however we’ll give attention to one: /api/customers that may return a listing of customers which might be saved on the respective database desk.

If you wish to use this pattern utility, please confer with the README file within the repository so as to make it run regionally.

Now, let’s do a few calls to one of many endpoints.

curl http://localhost:4000/api/customers
Enter fullscreen mode

Exit fullscreen mode

This could generate some telemetry knowledge, which might be exported to SigNoz OTEL collector.

You possibly can entry SigNoz UI at http://localhost:3301/application (after signing up) to see your Elixir Phoenix API being monitored. The opposite purposes that you simply see are pattern purposes that come bundled with the set up.

Elixir app being monitored on SigNoz dashboard
Elixir Phoenix API being monitored on the SigNoz dashboard. The opposite purposes are pattern apps that come bundled with SigNoz set up.

Monitor utility metrics of your Elixir app

SigNoz supplies out-of-box charts for utility metrics like latency, requests per sec, error proportion, and many others.

Monitor Elixir application metrics
You possibly can monitor latency, requests per sec, error proportion, and prime endpoints of your Elixir utility.

Analyze your tracing knowledge with the Traces tab

Your utility metrics are additionally seamlessly correlated with tracing knowledge. You possibly can select any timestamp or endpoint to discover Traces throughout that period.

Analyze your trace data with powerful filters
he Traces tab of SigNoz supplies you with highly effective filters to research your tracing knowledge.

Full breakdown of requests

You possibly can see an entire breakdown of the request with Flamegraphs and Gantt charts. You possibly can click on on any span within the spans desk to entry it.

From our Elixir utility, we are able to see a hint consisting of two spans. The guardian one corresponds to the HTTP request and the second corresponds to the database name.

Flamegraphs and Gantt Charts
You possibly can see the entire breakdown of your requests with particulars like how a lot time every operation took, span attributes, and many others.

Troubleshooting an error

SigNoz may also assist in troubleshooting errors with error monitoring.

For this, we’ll need to power an error and we are able to do that by doing the next request:

curl http://localhost:4000/api/customers/one thing
Enter fullscreen mode

Exit fullscreen mode

This can trigger an error as a result of this endpoint is anticipating an integer and never a string

You possibly can go to http://localhost:3301/errors to take a look at the errors in your utility.

Elixir application error monitoring
Monitor all errors at one place with Exceptions monitoring

Should you click on on the error, you’ll see some extra particulars in regards to the error and even the stack hint.

Stacktrace of errors in your Elixir apps in the SigNoz dashboard
See stacktrace of errors to dig deeper into why it occurred



Conclusion

Utilizing OpenTelemetry libraries, you possibly can instrument your Elixir purposes for establishing observability. You possibly can then use an open-source APM device like SigNoz to make sure the graceful efficiency of your Elixir purposes.

OpenTelemetry is the long run for establishing observability for cloud-native apps. It’s backed by an enormous neighborhood and covers all kinds of know-how and frameworks. Utilizing OpenTelemetry, engineering groups can instrument polyglot and distributed purposes with peace of thoughts.

SigNoz is an open-source observability device that comes with a SaaS-like expertise. You possibly can check out SigNoz by visiting its GitHub repo 👇

SigNoz GitHub repo

You probably have any questions or want any assist in setting issues up, be a part of our slack neighborhood and ping us in #assist channel.

SigNoz Slack community



Additional Studying

Implementing OpenTelemetry in Angular application

Monitor your Nodejs application with OpenTelemetry and SigNoz

Add a Comment

Your email address will not be published. Required fields are marked *