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.
