datadogAug 12, 2025

Scaling down to speed up: How we improved efficiency of live process metrics by 100x | Datadog (opens in new tab)

The provided content does not include the blog post itself. It contains Datadog’s navigation menu and a promotional link announcing its recognition as a Leader in the 2026 Gartner® Magic Quadrant™ for Observability Platforms, so there is insufficient technical material to summarize the article. ### Content Included - A link to Datadog’s Gartner announcement. - Navigation categories covering: - Infrastructure and application monitoring - Logs, databases, and data observability - Security - Digital experience monitoring - Software delivery - Service management - AI capabilities - The URL suggests the intended article may concern scaling process or pipeline efficiency, but its body is not present. Please provide the full blog post text for a substantive summary.

real-user-monitoringk8sdatadogobservability+4

datadogMay 23, 2024

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.

real-user-monitoringk8sdatadogobservability+4

datadogFeb 22, 2022

How Datadog uses Datadog to gain visibility into the Datadog user experience (opens in new tab)

Datadog’s product designers use their own monitoring tools to supplement interviews with quantitative insight into user behavior. By applying Real User Monitoring (RUM) and Logs to design questions, they made decisions about fonts, component functionality, and time-range input based on actual usage. This “dogfooding” approach improved products while making design collaboration faster and more evidence-based. ## Choosing a Monospace Font - Datadog uses monospace text for logs, stack traces, source code, container IDs, and dense data views. - Previously, users received different system fonts through a generic font stack, including Consolas, Menlo, and Courier. - The team used the browser’s CSS Font Loading API and RUM to determine which fonts users were actually seeing. - They analyzed the results in RUM Analytics and shared them through a dashboard with designers and engineers. - Datadog selected **Roboto Mono** as the standard font and used RUM after launch to verify that the rollout worked as intended. - Matching the existing visual proportions was important because font-size and character-width changes could disrupt tightly designed tables and other interfaces. ## Simplifying the DraggablePane Component - DraggablePane lets users resize adjacent content panels, but its small handle contained several controls that created visual clutter. - Custom loggers were added to the component and its draggable handle to track how users interacted with each feature. - Logs showed that almost no users used the minimize and maximize buttons, despite the space they occupied. - The team removed those buttons and replaced their functionality with a double-click on the handle. - Datadog notes that custom actions in RUM now provide a more direct way to collect this kind of interaction data. ## Expanding Custom Time-Range Syntax - Datadog initially offered only preset ranges such as 15 minutes, 1 hour, and 1 day. - The DateRangePicker introduced text-based custom ranges, but early versions supported only limited patterns such as “{N} months” or explicit dates. - Logs captured invalid user-entered time expressions, along with the page and country associated with each request. - The most common unsupported input involved “weeks,” including phrases like “last 1 week” and “last 2 weeks.” - The team used these patterns to prioritize improvements to the parser. - After adding support for common previously invalid inputs, the error rate fell from roughly 10 percent to 5–6 percent. ## Dogfooding and Collaboration - Designers tracked behavior, analyzed results, built dashboards, and documented findings using Datadog products. - Keeping data collection, analysis, and presentation in one platform made design reviews more efficient. - Shared dashboards and documentation helped designers and engineers collaborate around concrete evidence rather than assumptions. - Using the product internally also gave the team direct experience with the platform from a user’s perspective. Datadog’s examples show that quantitative product data works best alongside qualitative research: interviews explain user needs, while RUM and Logs reveal how often behaviors occur and which improvements will have the greatest impact.

real-user-monitoringdatabase-designdatadogux-design+4

datadogFeb 22, 2022

How Datadog uses Datadog to gain visibility into the Datadog user experience | Datadog (opens in new tab)

Datadog leverages its own monitoring tools to bridge the gap between qualitative user interviews and quantitative performance data. By "dogfooding" features like Real User Monitoring (RUM) and Logs, the product design team makes evidence-based UI/UX adjustments while gaining firsthand empathy for the user experience. This approach allows them to identify exactly how users interact with specific components and where current designs fail to meet user expectations. **Optimizing Font Consistency via CSS API Tracking** * To ensure visual precision in information-dense views like the Log Explorer, the team needed to transition from a generic system font stack to a standardized monospace font. * Designers used the Web API’s `Document.font` interface and the CSS Font Loading API via Datadog RUM to collect data on which specific fonts were actually being rendered on users' machines. * By analyzing a dashboard of these results, the team selected Roboto Mono as the standard, ensuring the new font’s optical size matched what the plurality of users were already seeing to avoid breaking embedded tables. **Simplifying Components through Interaction Logging** * The `DraggablePane` component, used for resizing adjacent panels, was suffering from UI clutter due to physical buttons for minimizing and maximizing content. * The team implemented custom loggers within Datadog Logs to track how frequently users clicked these specific controls versus interacting with the draggable handle. * The data revealed that the buttons were almost never used; consequently, the team removed them and replaced the functionality with a double-click event, significantly streamlining the interface. **Refining Syntax Support through Error Analysis** * When introducing the `DateRangePicker` for custom time frames, the team needed to expand the component's logic to support natural language strings. * By aggregating "invalid inputs" in Datadog Logs, the team could see the exact strings users were typing—such as "last 2 weeks"—that the system failed to parse. * Analyzing these common patterns allowed the team to update the parsing logic for high-demand keywords, which resulted in the component’s error rate dropping from 10 percent to approximately 5 percent. Leveraging internal monitoring tools allows design teams to move beyond guesswork and create highly functional interfaces. For organizations managing complex technical products, tracking specific component failures and interaction frequencies is an essential strategy for prioritizing the design roadmap and improving user retention.

real-user-monitoringdatabase-designdatadogux+4

datadogFeb 10, 2021

Engineering spotlight: Maël Nison | Datadog (opens in new tab)

Datadog announces that it has been named a Leader in the 2026 Gartner® Magic Quadrant™ for Observability Platforms. The announcement positions Datadog as a broad observability platform spanning infrastructure, applications, logs, security, digital experience, software delivery, service management, and AI. The provided content does not include Gartner’s detailed evaluation or the blog post’s supporting arguments. ## Recognition and Platform Scope - Datadog highlights its leadership placement in Gartner’s observability-platform research. - Its platform covers: - Infrastructure and container monitoring - Application performance monitoring and profiling - Database, data-stream, and jobs monitoring - Log management and observability pipelines - Cloud, application, workload, and code security - Browser and mobile real user monitoring - Synthetic monitoring, session replay, and error tracking - CI visibility, testing, code coverage, and feature flags - Incident response, service catalogs, SLOs, and workflow automation ## AI and Automation - Datadog presents AI as an integrated part of its platform through: - Bits AI agents and investigation tools - AI integrations and agent observability - GPU monitoring - MCP Server and agent-building capabilities - AI-assisted security and developer workflows - Additional automation features include Watchdog, fleet automation, workflow automation, and incident-management tools. ## Overall Positioning - The product catalog emphasizes a unified approach to monitoring technology environments rather than separate tools for infrastructure, applications, security, and user experience. - The platform also includes dashboards, alerts, notebooks, governance controls, access management, and mobile access. The announcement’s central message is that Datadog combines extensive observability coverage with security, delivery, service-management, and AI capabilities. Readers seeking the actual Gartner assessment should consult the linked Magic Quadrant resource, since the supplied text contains only the announcement and navigation information.

real-user-monitoringk8sdatadogobservability+4

datadogAug 13, 2018

Introducing Kafka-Kit: Tools for scaling Kafka | Datadog (opens in new tab)

Datadog’s “Kafka Kit” is a collection of operational tools designed to make Apache Kafka easier to scale and manage. The post argues that Kafka’s built-in administrative mechanisms become difficult to use safely as clusters grow, particularly when rebalancing partitions or adding and removing brokers. Kafka Kit automates these workflows while emphasizing balanced assignments, controlled changes, and operational visibility. ## Why Kafka Scaling Becomes Difficult - Growing Kafka clusters require frequent partition movement and broker rebalancing. - Native Kafka reassignment workflows can involve large, complex JSON configurations. - Poorly planned changes can create: - Uneven storage and traffic distribution - Excessive network and disk I/O - Overloaded brokers - Extended recovery times - Operational changes must account for replication, leadership, broker capacity, and rack or availability-zone placement. ## Kafka Kit’s Approach - Kafka Kit provides reusable tooling for common Kafka administration tasks. - The tools generate and apply partition assignments instead of requiring operators to construct them manually. - Assignments can be optimized for more even distribution of: - Partitions - Replicas - Leaders - Storage and traffic - The tooling is intended to support both routine balancing and larger cluster changes, such as adding or decommissioning brokers. ## Safer Partition Reassignment - Reassignments can be performed incrementally rather than moving all partitions at once. - Changes can be throttled to limit their effect on production workloads. - Operators can inspect proposed assignments before applying them. - Controlled movement reduces the risk of saturating Kafka brokers, disks, or network links. - The approach makes long-running migrations easier to monitor and interrupt if necessary. ## Operating Kafka at Scale - Datadog built the tools from its experience running Kafka as a critical part of its data infrastructure. - At large scale, Kafka administration needs to be repeatable and automatable rather than dependent on manual intervention. - Separating planning from execution allows teams to validate capacity and placement before changing the cluster. - Standardized tooling also helps reduce the chance of configuration errors during high-risk maintenance operations. Kafka Kit is most useful for teams operating Kafka clusters large enough that manual partition management is unreliable or disruptive. Automating assignment generation, throttling, validation, and broker lifecycle changes can make scaling more predictable and safer.

real-user-monitoringk8sdatadogobservability+4