Using Side-Eye is free

A debugger for production
Go systems

Dynamically instrument your software in production with no code changes, re-compiles or restarts. Take snapshots of your distributed system. Go deeper in root causing failures.

Go to the app or try a demo

Open snapshot

Back to snapshots list

Captured data organized in SQL tables

Detailed stacks view including captured data

Back to flame graph

running_statements

Package:

pkg/sql/connExecutor.execStmtInOpenS...

Columns

goroutine_id, ex.state.mu.txn.mu.ID, sql, s...

Open a table

Back to tables list

Details on the goroutine executing a particular query

Navigate across gRPC network calls from to the server-side goroutine handling this request

Data collected for a specific function across all goroutines

Back to client-side goroutine

Snapshots list

About us

Side-Eye brings dynamic instrumentation to Go systems

Even the best-instrumented systems aren't immune to the challenges of troubleshooting, on-call burdens, and debugging that can overwhelm teams. Getting to a point where you can call your system well-instrumented is an expensive endeavor. Side-Eye changes that calculation by enabling developers and operators to instrument the software as questions arise, without changing code, redeploying, or restarting anything.

Side-Eye is a modern take on the power of debugger, but one that works for teams of people operating distributed production systems. Instead of relying exclusively on existing log messages, Side-Eye lets you interactively collect new signals and data on the fly, getting you to the root cause. Never bottom out at a perplexing chart again!

Demo

Side-Eye is a next-generation debugger for teams that care about mission-critical back end systems

Side-Eye is a distributed debugger that you'll enjoy using. It is featureful and built with the user in mind so that you can click your way to answering any question about software dynamics.

Features

What’s included?

Side-Eye is debugger that you'll enjoy using. It is featureful and built with the user in mind so that you can click your way to answering any question about software dynamics.

Distributed snapshots

Capture snapshots of a distributes system, including stack traces and function variables
Flexible deployment

Use Side-Eye by either installing our agent or by linking in our Go library
Data analysis

Query the data in snapshots using SQL and build reports
Network awareness

Follow gRPC network calls to understand what a distributed operation is blocked on
Dynamic instrumentation

Dynamically instrument your programs in production with new logs and metrics without changing source code, recompiling, or re-deploying
Debug with your team

All the collected data is shared with your colleagues. Everybody's instrumentation contributions help everybody else in the future

Use cases

Deeply understand the state of your distributed system with snapshots

Capture deep information about the state of execution of every goroutine in the system at a point in time. Explore the stack traces of all the goroutines running in the snapshotted processes in different ways – e.g. as a flame graph showing an aggregated view of all the goroutines, or as SQL tables exposing variables and expression data collected from different modules.

Dynamically instrument software

Add new logs and metrics to your system at run time, without changing the source code, recompiling or restarting any processes. Don’t wait for the next release to get new telemetry.

Root-cause rare errors through rich, dynamic error reports

Imagine a Sentry error or crash report that lets you say “next time this failure happens, also include these variables and expressions from across the stack in the report”. Errors that are hard to reproduce used to be hard to investigate; dynamic error reports give you recourse without having to add expensive new static instrumentation to your software.

Control the costs of telemetry

Too much junk in your Splunk? Paying too much for Datadog time series that nobody ever looks at? Dynamic instrumentation lets you enable telemetry when it’s needed, so you don’t have to decide a priori what’s worth instrumenting.

Replace rigid status pages with flexible dashboards that evolve independently

Side-Eye distributed snapshots can be analyzed through SQL queries joining and aggregating the collected data. For example, a table can be created that lists pairs of related operations – when monitoring a SQL database, one could define a table listing pairs for SQL queries/transactions that are blocked on each other. Such derived tables are high-level "reports" about the current state of the system as it was captured in a snapshot. They can augment or replace HTTP endpoints commonly programmed into services for status reporting and debugging purposes. Side-Eye reports are decoupled from the software's release cycle and can evolve on the fly, as needed. The reports can also be included in Grafana dashboards.

Instrument your software and debug with your whole team, over time

Complex systems need to be instrumented and observed by a team of people with expertise in different services and modules. Side-Eye is a multi-player debugger – everybody in the organization contributes to specifying what data should be collected and how it should be organized, and any collected data is naturally shared.

Integrate into test environments to understand test flakes

How many times have you looked at a test failure without having enough information to understand what happened? With Side-Eye, a test failure or timeout can include rich data about the state of the system at the time of the failure, giving you something to look at.

Empower the support team to ask deeper questions

It’s hard for support engineers that haven’t been involved directly in writing the code to gain a deep understanding of the system. Side-Eye brings engineering, DevOps, SRE, and support together, letting everybody collaborate on ever-better incident response.

The Blog