How we migrated our static analyzer from Java to Rust | Datadog (opens in new tab)

Datadog migrated its static code analyzer from Java to Rust to improve performance, resource usage, and operational reliability. The rewrite addressed limitations that became increasingly significant as the analyzer processed larger codebases and ran more analyses in parallel. Rather than replacing everything at once, the team preserved existing behavior and introduced the Rust implementation incrementally.

Why Move from Java to Rust

• Static analysis is computationally intensive and often runs across many files simultaneously.
• The Java implementation introduced overhead from:
  • Garbage collection
  • High memory consumption
  • Startup and deployment costs
  • Difficulty achieving predictable performance under heavy workloads
• Rust offered:
  • Native performance
  • More predictable memory usage
  • Lightweight binaries
  • Safe concurrency without a garbage collector

Preserving Analyzer Behavior

• The primary challenge was maintaining compatibility with the existing analyzer and its rules.
• The migration had to preserve:
  • Parsing behavior
  • Finding locations and diagnostic messages
  • Rule semantics
  • Output formats consumed by Datadog’s products and integrations
• The team treated the existing implementation as the behavioral reference while rebuilding internal components in Rust.

Incremental Migration Strategy

• Datadog avoided a risky “big bang” rewrite.
• Functionality was migrated in stages, allowing the team to:
  • Compare Java and Rust results
  • Detect behavioral differences
  • Benchmark performance
  • Roll back or isolate problematic changes
• Parallel validation helped ensure that improvements in speed did not produce inconsistent security findings.

Engineering Trade-offs

• Rust improved control over memory and execution, but introduced a steeper learning curve and more explicit systems-level design.
• The team had to redesign interfaces between components rather than mechanically translate Java code.
• Particular attention was required for:
  • Error handling
  • Concurrency
  • Cross-platform builds
  • Dependency management
  • Observability and debugging

Results and Lessons

• The Rust implementation provided a stronger foundation for scaling static analysis workloads.
• More predictable resource usage makes it easier to run analyses reliably in CI and other automated environments.
• The migration demonstrated that large infrastructure rewrites are most manageable when correctness is continuously checked against the existing system.

The practical recommendation is to approach similar rewrites incrementally: define compatibility requirements first, compare old and new implementations continuously, and use measured performance and resource data—not language preference alone—to guide the migration.