DEV Community

Cover image for Uptrace v2.0: The Future of Observability is Here
Uptrace profile image Alexandr Bandurchin
Alexandr Bandurchin for Uptrace

Posted on • Originally published at uptrace.dev

Uptrace v2.0: The Future of Observability is Here

#monitoring #architecture #news #performance

The Uptrace team is thrilled to announce the release of v2.0 — our biggest update yet! This release represents a complete reimagining of how observability data should be stored, queried, and managed. With multi-project support, revolutionary JSON-based storage, powerful data transformations, and a host of developer-friendly features, Uptrace v2.0 is designed to scale with your growing infrastructure needs.

🚀 What Makes v2.0 Special

This isn't just another incremental update — it's a complete architectural overhaul that delivers 5-10x faster query performance while making Uptrace more flexible and user-friendly than ever before.

Ready to see what all the fuss is about? Let's dive in.

Multi-Project Management Made Simple

Gone are the days of wrestling with configuration files just to manage basic settings. Uptrace v2.0 introduces intuitive multi-project support that lets you create and manage projects, users, and organizations directly through the UI.

Don't worry — if you prefer configuration files, they're still fully supported:

# Initial data created on first startup
seed_data:
  users:
    - key: user1 # Unique identifier for referencing in relationships
      name: Admin
      email: admin@uptrace.local
      password: admin # TODO: Change default password!

  orgs:
    - key: org1 # Unique identifier for referencing below
      name: Org1

  org_users:
    - key: org_user1
      org: org1 # References org.key above
      user: user1 # References user.key above
      role: owner

  projects:
    - key: project1 # Unique identifier for referencing below
      name: Project1
      org: org1 # References org.key above
Enter fullscreen mode Exit fullscreen mode

The new key fields allow Uptrace to automatically create, update, and remove resources as needed, making multi-tenant setups easier than ever.

JSON Storage: 10x Faster Queries

Here's where things get exciting. Uptrace v2.0 fully embraces ClickHouse's new JSON data type, delivering performance improvements that will transform your debugging workflow.

Why this matters: Traditional observability tools struggle with the variable, nested structures found in spans and logs. They either flatten everything (losing valuable context) or store data inefficiently (sacrificing performance). ClickHouse's JSON type solves both problems elegantly.

The magic: JSON data is stored directly in columns while maintaining columnar performance benefits. It automatically parses JSON on insertion and enables lightning-fast queries of nested fields using simple dot notation in SQL. No more expensive ETL processes or performance trade-offs.

Real-world impact: Query performance improves by up to 10x in many scenarios. Whether you're analyzing millions of telemetry records or drilling down into specific trace patterns, Uptrace v2.0 handles it with ease.

Here is how it looked without JSON data type (2.754 sec):

SELECT count()
FROM spans_old
WHERE JSONExtractString(attributes, 'service_name') = 'checkout';

┌─count()─┐
│ 1250345 │
└─────────┘

1 row in set. Elapsed: 2.754 sec. Processed 50.00 million rows, 8.43 GB (18.15 million rows/s., 3.06 GB/s.)
Enter fullscreen mode Exit fullscreen mode

And with JSON data type (0.287 sec):

SELECT count()
FROM spans_new
WHERE attributes.service_name = 'checkout';

┌─count()─┐
│ 1250345 │
└─────────┘

1 row in set. Elapsed: 0.287 sec. Processed 50.00 million rows, 3.12 GB (174.21 million rows/s., 10.87 GB/s.)
Enter fullscreen mode Exit fullscreen mode

Redesigned Overview

Uptrace now lets you customize your home page by combining multiple dashboards on a single view. For example, you can display your three most important dashboards on the home page to quickly monitor your application's health at a glance.

This flexible layout eliminates the need to navigate between multiple pages during incident response or routine monitoring. You can mix and match different dashboard types—such as service performance metrics, error tracking, and infrastructure health—creating a unified command center tailored to your team's specific needs.

Overview dashboards

A Query Builder You’ll Actually Use

The redesigned query builder makes exploring your data effortless.

Key improvements:

  • Intelligent suggestions for attributes and values
  • Quick toggles to enable/disable query parts during exploration
  • Full support for search clauses, perfect for narrowing down metrics or errors: 
where host_name = "myhost" | search foo|bar
Enter fullscreen mode Exit fullscreen mode

New query builder

Iterate, explore, and drill down — faster than ever.

Data Transformations: Your Data, Your Rules

Uptrace v2.0 introduces a powerful data transformation system that lets you modify and enrich incoming telemetry data in real-time. Think of it as middleware for your observability pipeline.

What you can accomplish:

  • Rename, delete, or restructure attributes on the fly
  • Parse and convert data types (strings to numbers, duration parsing, etc.)
  • Apply conditional logic based on deployment environment or span characteristics
  • Sample or drop spans based on custom criteria
  • Enrich data with additional context

Advanced scripting capabilities: For complex scenarios, Uptrace includes a scripting system based on expr-lang with extensive parsing and manipulation functions:

# Parse string attributes as numeric values
setAttr("elapsed_ms", parseFloat(attr("elapsed_ms")))

# Reduce attribute cardinality with pattern replacement
setAttr("http_target", replaceGlob(attr("http_target"), "/user/*/list/*", "/user/{userId}/list/{listId}"))

# Convert logs to spans dynamically
setSpanName(attr("log_message"))
setLogName("")
Enter fullscreen mode Exit fullscreen mode

This system operates across four main data scopes (spans, logs, events, datapoints) and supports the Expr language for conditional logic, giving you unprecedented control over your telemetry data.

Enterprise-Ready Security Features

Uptrace v2.0 includes built-in support for enterprise security requirements:

Single Sign-On (SSO): Configure OIDC and SAML authentication directly through the UI. No more wrestling with complex configuration files.

Multi-Factor Authentication (MFA): Add an extra layer of security with built-in 2FA support.

Note: SSO and MFA features are available in the Premium Edition.

Smarter Trace Navigation

We've enhanced span linking with bidirectional backlinks. Previously, if span A linked to span B, you could only navigate from A to B. Now, Uptrace automatically displays a link from B back to A, making trace navigation more intuitive and comprehensive.

Zero-Hassle SSL with Let's Encrypt

Setting up HTTPS is now as simple as adding a few lines to your configuration:

# Automatic certificate issuance and renewal via Let's Encrypt
certmagic:
  enabled: true # Enable Let's Encrypt certificate management
  staging_ca: false # Use staging environment for testing
  http_challenge_addr: :80 # Address for HTTP-01 challenge validation
Enter fullscreen mode Exit fullscreen mode

Uptrace handles certificate provisioning and renewal automatically, so you can focus on what matters most — understanding your applications.

Flexible Data Retention

Different data types have different retention requirements. Uptrace v2.0 lets you configure separate retention policies for each project and data type:

  • Spans: High-resolution traces for recent debugging
  • Logs: Detailed application logs with custom retention
  • Events: System events with their own lifecycle
  • Metrics: Long-term performance data

This granular control helps optimize storage costs while maintaining access to the data you need most.

Large-Scale Trace Visualization

Uptrace v2.0 includes enhanced visualization capabilities for massive traces containing 10,000 to 1,000,000 spans. Whether you're debugging complex microservices interactions or analyzing batch processing workflows, Uptrace can handle the load.

On systems with limited memory, you can configure how many spans Uptrace will analyze to build the trace:

# Trace query resource limits
trace:
  # Maximum number of spans to return in a single query
  # Prevents UI timeouts and excessive memory usage
  #query_limit: 200_000

  # Maximum memory usage per query (in bytes)
  # Prevents OOM errors from complex queries
  # Adjust based on available system memory
  #max_memory_usage_bytes: 200_000_000
Enter fullscreen mode Exit fullscreen mode

Migration Strategy

We recommend running Uptrace v2.0 in parallel with your existing v1.x instance during the transition:

  1. Deploy v2.0 alongside v1.x to validate functionality
  2. Write data to both instances simultaneously
  3. Switch over once sufficient data has been collected in the new instance

This approach ensures minimal downtime and data loss — the same battle-tested strategy we use for Uptrace Cloud deployments.

Ready to Experience the Future of Observability?

Uptrace v2.0 represents a fundamental shift in how observability should work — faster, more flexible, and built to scale with your infrastructure. Whether you're debugging complex distributed systems or analyzing massive volumes of telemetry data, v2.0 provides the tools you need without the traditional performance penalties.

Get started today: Download Uptrace v2.0 and experience firsthand how architectural innovation can transform your observability stack.

We've also added comprehensive deployment guides to get you up and running quickly:

Ready to see what 10x faster queries feel like? Download Uptrace v2.0 and discover observability without the wait.

Top comments (0)