Testing Tools
Raygun occupies a specific niche in the error monitoring market: a platform that combines crash reporting, error tracking, and real user monitoring (RUM) in a single product, with a focus on application performance alongside error detection. Where most error tracking tools ask "what broke?", Raygun also asks "
CI/CD
Traditional CI/CD testing stops at the deployment boundary. Tests run before production; production is where you find out if the tests were sufficient. This creates a one-way information flow: tests inform deployments, but production never informs tests. The result is systematic blind spots. Tests cover the paths engineers
Observability
Chaos engineering without observability is guesswork. You inject a fault, something breaks (or doesn't), and you're left reading error rates and hoping you measured the right thing. When you combine chaos experiments with trace-based and metric-based assertions, each experiment becomes a falsifiable test: "
Testing Strategy
Chaos engineering is the practice of deliberately injecting failures into a system to verify it behaves correctly when real failures occur. Without observability, chaos experiments are blind — you inject a fault and cannot tell whether your system degraded gracefully or silently failed. Combining chaos engineering with structured observability turns experiments
Testing Tools
Production applications generate errors constantly. Most of them are noise — bots hitting 404s, occasional network timeouts, browser extensions injecting malformed scripts. A small subset are real bugs that affect real users and need to be fixed. The challenge is separating signal from noise efficiently. Bugsnag was designed to solve this
AIOps
Most incident management tools answer the question "who should we page?" BigPanda is built to answer a harder question: "what is actually causing this?" BigPanda is an AIOps platform that ingests alerts from across your stack — monitoring tools, CI/CD pipelines, testing infrastructure, cloud providers, application
Testing
OpenTelemetry semantic conventions define standard names and attributes for common operations — HTTP requests, database calls, messaging systems, and more. When your instrumentation follows them, your observability data works correctly with standard dashboards, automatic anomaly detection, and cross-service correlation. When you deviate from semantic conventions — even slightly — things break in
Testing
When you add OpenTelemetry instrumentation to your codebase, you're writing code that needs to be tested like any other code. A function that creates a span, records attributes, and handles errors can have bugs. Without tests, you discover them in production when your traces are missing or incorrect.
Testing
Sampling is one of the most consequential decisions in an observability setup — and one of the least tested. When sampling is misconfigured, you lose exactly the traces you most need: errors, slow requests, and anomalies. Or you over-sample and blow your observability budget. Testing your sampling strategy should be
Testing
Your OTEL metrics instrumentation is only as good as your confidence that it measures what it claims to measure. A checkout success counter that double-counts, a latency histogram with wrong boundaries, or an alert rule that fires too late (or never) — these are observability bugs that cause real production
Testing
Most teams think of OpenTelemetry as a production concern — you instrument your app, deploy it, and then your observability stack tells you what's happening. CI/CD is where you validate code; OTEL is where you debug production. These two worlds don't meet. This is a missed
Observability
Observability tooling has matured to the point where the same signals you use to debug production incidents can drive your test assertions. OpenTelemetry (OTel) gives you a vendor-neutral SDK to emit traces, metrics, and logs — and with a small amount of setup you can capture those signals inside your