CodeXray Observability
Modern applications fail in modern ways — across services, dependencies, infrastructure, and third parties. Yet most teams still investigate incidents the old way: hopping between dashboards, correlating by hand, and paying per-GB penalties for the privilege.
CodeXray Observability is a full-stack observability (FSO) platform built on AI, OpenTelemetry, and eBPF. It unifies metrics, events, logs, and traces (MELT) into a single correlated view — so SREs can answer what broke, why, and what changed in seconds, not hours.
CodeXray is designed with application-first performance monitoring as a core primitive — not an add-on. Rate, Errors, and Duration (including p95/p99) are native APM signals, slice-able by service, endpoint, tenant, region, and version without cost shock.
The Observability Challenge
Engineering and SRE teams face a compounding set of problems that classic APM tools amplify rather than solve:
Cost unpredictability — usage-based pricing across metrics, traces, and logs turns every traffic spike into a billing event. Retention becomes a negotiation with finance, not an engineering decision.
Vendor lock-in — proprietary agents, schemas, and workflows make telemetry non-portable. Replacing or augmenting tools requires re-instrumenting the entire stack.
Siloed signals — metrics live here, traces there, logs somewhere else. During incidents, teams lose minutes (or hours) stitching context manually.
Alert noise without cause — dashboards tell you something is wrong. Identifying whether it's code, dependency, or infrastructure still takes human detective work.
CodeXray addresses these through open standards, unified correlation, and (soon) AI-assisted triage — without forcing a rip-and-replace migration.
How CodeXray Works
Telemetry flows from your applications and infrastructure into CodeXray through open, standards-based pipelines. There's no proprietary agent requirement — OpenTelemetry is a first-class citizen, and eBPF-based collection works where instrumentation isn't feasible.
CodeXray ingests native OTel metrics, traces, and logs. You retain full ownership and portability of your telemetry — no re-instrumentation required to adopt, replace, or run CodeXray alongside existing tools.
What You Get Today
CodeXray Observability ships the following modules out of the box. Each is wired end-to-end — from collection through UI — and available on day one.
Application Performance Monitoring
- Overview — RED metrics (Rate · Errors · Duration p50/p95/p99), dependency map, SLO status per service
- Distributed Traces — full span trees, latency breakdown by hop, error and slow-request filtering
- Application Logs — centralized log view, pattern extraction, correlated to the same trace
- Runtime Insights — JVM, .NET, Python runtime metrics; GC, memory, threadpools, CPU
- Continuous Profiling — always-on CPU/memory profiles for supported runtimes
- Deployments — deployment markers overlaid on RED signals; spot regressions by release
- DB Queries — slow query analysis correlated from the application side
Infrastructure
- Nodes — per-node CPU, memory, disk, network, container inventory; eBPF-sourced TCP maps
- Topology — auto-discovered service/infra graph based on actual traffic (not config)
- Kubernetes — cluster agent for pod/deployment/workload metrics
Database Monitoring
- Supported engines — PostgreSQL, MySQL, MongoDB, Redis, Memcached (via auditors); plus MSSQL, Oracle, Cassandra, Couchbase (via db-agent)
- Top Queries · Active Connections · Engine Metrics — dedicated views per database
End-User Monitoring
- BRUM — browser RUM agent (errors + traces from the browser)
- MRUM — mobile crash reports, performance, sessions, user journeys
Synthetic Monitoring
- User-journey checks — run key flows (login, search, checkout) in a real browser on a schedule; pass/fail, availability, Core Web Vitals, and the exact step that broke
Collaboration & Ops
- Alerts — integrated channels: Slack · PagerDuty · Microsoft Teams · Webhook
- Deployment Tracking — auto-detected rollouts, correlated with SLO breaches
- Anomaly Detection — baseline-aware alerting on RED signals
- RBAC + Multi-tenancy — tenants, projects, roles with fine-grained permissions
- SSO — enterprise identity integration
Supported Integrations
| Category | Supported Today |
|---|---|
| Languages / Runtimes | Java (JVM · OTel javaagent), .NET (native agent + OTel), Python, Node.js, Go |
| Databases | PostgreSQL, MySQL, MongoDB, Redis, Memcached, MSSQL, Oracle, Cassandra, Couchbase |
| Infrastructure | Linux (eBPF node agent, kernel ≥ 4.16), Windows (windows_exporter), Kubernetes (cluster agent), generic VMs (vm-agent) |
| Client-side | Browsers (BRUM JS agent), Mobile (MRUM SDK — crashes/perf/sessions) |
| Protocols | OpenTelemetry OTLP (gRPC + HTTP), Prometheus remote write, SkyWalking (via transformer bridge) |
| Deployment | SaaS (EU · NA regions), Docker Compose, Kubernetes manifests; Helm charts available for agents |
| Alerting Channels | Slack, PagerDuty, Microsoft Teams, Generic Webhook |
Core Capabilities
1. RED-Centric Application Performance Monitoring
Rate, Errors, and Duration — with percentile-accurate latency tracking — are the primary lens into application health. High-cardinality slicing by service, endpoint, method, tenant, region, and version lets you find regressions fast without pre-aggregation penalties.
Use cases: monitoring critical application and service health · detecting error spikes and latency regressions · understanding behavior under traffic surges.
2. Error Intelligence & Latency Breakdown
CodeXray ingests application errors, exceptions, and slow-request signals, then clusters them automatically by fingerprint to surface patterns instead of raw log noise. Latency is decomposed across application logic, database, and dependencies — so you see where the time is spent.
Use cases: faster incident triage · identifying top error patterns · pinpointing the offending dependency or code path.
3. Full-Stack Telemetry Correlation
Metrics, traces, logs, and infrastructure signals are correlated in a single view. Dependency-aware service maps and change-aware analysis (deployments, config, traffic shifts) answer the most important question during an incident: what changed?
Use cases: root-cause analysis · eliminating tool-hopping during incidents · shortening MTTR.
4. Predictable Pricing & Deployment Flexibility
Node-based licensing for self-hosted, per-GB ingestion for SaaS — no span-wise surprises. Deploy on-prem, hybrid, or fully managed. Columnar storage means long-term retention without exponential cost.
Use cases: cost control for high-volume services · data residency compliance · scaling without cost shock.
Investigation Flow
When RED metrics signal an anomaly, CodeXray guides SREs down a branched triage path — so you're never staring at a wall of unsorted telemetry.
Traditional APM surfaces symptoms. CodeXray's branched triage gets you to cause — reducing cognitive overhead for teams transitioning from classic bytecode-instrumentation flows.
Key Differentiators
| Capability | Business Value |
|---|---|
| AI + OTEL + eBPF Foundation | Modern telemetry stack: open standards for portability, eBPF for zero-code instrumentation, AI for triage velocity. |
| Columnar Storage (ClickHouse) | High compression ratios and sub-second queries across billions of events — enabling long retention without cost explosion. |
| Full-Stack Correlation | Metrics, traces, logs, and infra signals in one model — no tool-hopping during incidents. |
| Progressive Migration | Run alongside your existing APM. Fork OTel output to both systems and cut over when — and if — outcomes validate. |
| Predictable Pricing | Node-based or per-GB ingestion. No per-span charges. Customers typically see ~50% cost reduction vs. legacy APM. |
CodeXray is designed to coexist with your current observability stack. Branch OTel output to CodeXray in parallel, validate outcomes on real workloads, and only scale once the team is confident. No forced cutover.
Who Benefits
SRE & Platform Teams
Faster MTTR — branched triage flows and cross-signal correlation cut investigation time. Less noise — fingerprinted error clusters replace raw log firehoses.
Engineering Teams
Same-day insight into production behavior — RED metrics and latency decomposition surface regressions during rollout, not weeks later. OpenTelemetry-native means no vendor-specific instrumentation to learn.
Engineering Leadership
Cost predictability — node-based and per-GB models align spend to infrastructure, not telemetry spikes. Executive summaries — daily highlights/lowlights and incident timelines deliver reliability metrics without manual reporting.
DevOps & SecOps
Open architecture — telemetry stays portable. Deployment flexibility — on-prem, hybrid, or SaaS to match compliance and residency requirements.
Getting Started
CodeXray is built for progressive, low-risk adoption:
- Instrument once with OpenTelemetry — fork output to CodeXray in parallel with your existing APM.
- Validate on real workloads — start with 1–2 critical services and compare RED, error, and latency signals side-by-side.
- Expand gradually — scale by service, environment, or use case. Decommission legacy APM only when outcomes are proven.
Continue to Installation for deployment options, or review Requirements for prerequisites. For a deeper technical view, see Architecture.
Next Steps
Installation Guide — pick SaaS (self-onboarding in ~5 min) or self-host with Docker Compose / Kubernetes.
Requirements — system prerequisites, supported languages, and infrastructure compatibility.
Architecture — deep dive into the CodeXray platform, data model, and correlation engine.