My First Observability Journey with OpenTelemetry and SigNoz

Yamini Kotturi — Sun, 19 Jul 2026 06:53:56 +0000

Introduction

While building applications, I always focused on making my code work. But I wanted to understand what happens inside an application when something fails.

During the Agents of SigNoz Hackathon, I explored application observability by creating a Python application, instrumenting it using OpenTelemetry, and visualizing traces using SigNoz.

This blog explains my complete hands-on experience, including the setup process, debugging issues, and the final results.

Setting Up My Python Application

I created a simple Python application that simulates different application workflows:

User login processing
Fetching user data
Generating AI responses

The goal was to generate traces and observe the application behavior.

I configured OpenTelemetry to capture application execution details and send the trace data to SigNoz.

Debugging My First Issue

During the setup process, I encountered a Python syntax error.

The problem happened because an import statement was accidentally placed on the same line as another statement.

Error:

SyntaxError: invalid syntax

After fixing the code structure, the application started running successfully.

Sending Traces to SigNoz

After successful execution, my application started creating traces.

The terminal output showed different application steps:

User login processed
Fetching user data
Generating AI response
Done sending trace

These operations were captured as telemetry and sent to SigNoz.

Exploring Traces in SigNoz

The most exciting part was seeing my application's trace inside the SigNoz dashboard.

The trace view showed:

Trace ID
Span information
Execution duration
Error status
Events generated during execution

This helped me understand how a single request flows through different parts of an application.

Understanding Errors Through Traces

One interesting observation was that SigNoz captured application errors clearly.

For example, my trace showed:

Status Code: Error
Status Message: Exception: AI service timeout

Instead of only seeing a failed execution in the terminal, I could identify exactly which operation caused the problem.

This showed me how observability makes debugging easier.

Viewing Application Performance

The SigNoz service dashboard provided an overview of my application:

Application name
P99 latency
Error rate
Operations per second

This dashboard made it easy to understand the overall health and performance of the application at a glance.

Challenges I Faced

Configuration Errors

Connecting OpenTelemetry with SigNoz required understanding how telemetry moves between different components.

Python Application
↓
OpenTelemetry SDK
↓
Telemetry Collector
↓
SigNoz Dashboard

Debugging Trace Errors

Some traces contained errors like AI service timeout. Instead of ignoring them, I used SigNoz to analyze where the failure happened.

What I Learned

This project helped me understand:

✅ How OpenTelemetry collects telemetry data
✅ How traces represent application workflows
✅ How SigNoz helps debug applications
✅ Why observability is important for modern software systems

Before this experience, I mainly checked whether my application worked. Now I understand that knowing why something failed is equally important.

Conclusion

Building this project gave me practical exposure to observability concepts.

Using OpenTelemetry and SigNoz, I was able to monitor my Python application, view traces, analyze errors, and better understand application behavior.

This hackathon helped me move beyond simply writing code and start thinking about building reliable, observable, and maintainable applications.

DEV Community: Yamini Kotturi

My First Observability Journey with OpenTelemetry and SigNoz