The provided text does not include the blog post itself. It contains Datadog’s navigation menu and a promotional link announcing its recognition as a Leader in Gartner’s 2026 Magic Quadrant for Observability Platforms, but no technical discussion or conclusions from the referenced article.
## Available content
### Datadog’s observability platform
- Datadog promotes products for:
- Infrastructure and Kubernetes monitoring
- Application performance monitoring and profiling
- Logs, databases, and data observability
- Security and cloud protection
- Real-user and synthetic monitoring
- CI/CD and software delivery
- Incident and service management
- AI-powered investigation and automation
### Gartner recognition
- The page links to Datadog’s announcement that it was named a Leader in the Gartner Magic Quadrant for Observability Platforms.
- The excerpt does not provide Gartner’s evaluation criteria, Datadog’s strengths or weaknesses, or supporting evidence.
Please provide the article body or a working text extract for an accurate technical summary.
Go 1.18 introduced major profiling improvements alongside features such as generics and fuzzing. Its Linux CPU profiler became substantially more accurate on multicore systems by addressing dropped `SIGPROF` signals, and profiler labels received an important correctness fix. These changes strengthened Go’s ability to connect continuous profiling data with tracing systems such as Datadog.
## More Accurate Linux CPU Profiling
- Earlier Go versions used `setitimer(2)` to request a `SIGPROF` signal every 10 ms of CPU time.
- On busy multicore systems, Linux could generate multiple signals within a single kernel “jiffy” window, but standard POSIX signals do not queue.
- As a result, many signals were dropped:
- A service using 20 CPU cores might generate roughly 2,000 profiling signals per second.
- Its Go profile could contain only about 240 samples per second.
- Linux’s software clock, commonly operating at 250 Hz, could only measure CPU time in roughly 4 ms intervals. This caused signal bursts and undercounted CPU usage.
- `setitimer(2)` also distributed process-directed signals unevenly across threads, creating additional profiling bias.
## Combining `timer_create` and `setitimer`
- `timer_create(2)` provided more reliable per-thread signal accounting and avoided most of the signal-dropping and thread-bias problems.
- Its drawback was that the profiler needed awareness of every thread, including threads created independently by cgo code.
- The Go 1.18 fix combined both timer mechanisms:
- The signal handler identifies the signal source.
- Signals from inferior sources are discarded.
- The implementation accounts for short-lived threads and cgo edge cases.
- The work originated from investigations into Go issues GH 35057 and GH 14434 and was developed through collaboration between contributors and Go maintainers.
## Profiler Label Correctness
- Profiler labels, also called pprof labels or tags, associate key/value metadata with goroutines.
- Labels are inherited by child goroutines and appear in CPU and goroutine profiles, enabling profiles to be filtered by request, service, or trace metadata.
- Testing at Datadog revealed that some stack samples were missing labels they should have carried.
- The cause was a CPU profiler lookup using the wrong goroutine reference.
- The fix changed the profiler to use `gp.m.curg`, the thread’s actual current goroutine, rather than relying on `gp`, which can differ in certain runtime situations.
Go 1.18’s profiling changes made CPU measurements more trustworthy on Linux and improved the accuracy of metadata attached to profile samples. Together, they provided a stronger foundation for correlating Go profiling with distributed tracing.
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.
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.
Datadog’s container observability team significantly improved the performance of kube-state-metrics (KSM) by contributing core architectural enhancements to the upstream open-source project. Faced with scalability bottlenecks where metrics collection for large clusters took tens of seconds and generated massive data payloads, they revamped the underlying library to achieve a 15x improvement in processing duration. These contributions allowed for high-granularity monitoring at scale, ensuring that the Datadog Agent can efficiently handle millions of metrics across thousands of Kubernetes nodes.
### Challenges with KSM Scalability
* KSM uses the informer pattern to expose cluster-level metadata via the Openmetrics format, but the volume of data grows exponentially with cluster size.
* In high-scale environments, a single node generates approximately nine metrics, while a single pod can generate up to 40 metrics.
* In clusters with thousands of nodes and tens of thousands of pods, the `/metrics` endpoint produced payloads weighing tens of megabytes.
* The time required to crawl these metrics often exceeded 15 seconds, forcing administrators to reduce check frequency and sacrifice real-time data granularity.
### Limitations of Legacy Implementations
* KSM v1 relied on a monolithic loop that instantiated a Builder to track resources via stores, but it lacked efficient hooks for metric generation.
* The original Python-based Datadog Agent check struggled with the "data dump" approach of KSM, where all metrics were processed at once during query time.
* To manage the load, Datadog was forced to split KSM into multiple deployments based on resource types (e.g., separate deployments for pods, nodes, and secondary resources like services or deployments).
* This fragmentation made the infrastructure more complex to manage and did not solve the fundamental issue of inefficient metric serialization.
### Architectural Improvements in KSM v2.0
* Datadog collaborated with the upstream community during the development of KSM v2.0 to introduce a more extensible design.
* The team focused on improving the Builder and metric generation hooks to prevent the system from dumping the entire dataset at query time.
* By moving away from the restrictive v1 library structure, they enabled more efficient reconciliation of metric names and metadata joins.
* The resulting 15x performance gain allows the Datadog Agent to reconcile labels and tags—such as joining deployment labels to specific metrics—without the significant latency overhead previously experienced.
Contributing back to the open-source community proved more effective than maintaining internal forks for scaling Kubernetes infrastructure. Organizations running high-density clusters should prioritize upgrading to KSM v2.0 and optimizing their agent configurations to leverage these architectural improvements for better observability performance.
Datadog contributed major scalability improvements to kube-state-metrics (KSM), after discovering that its metric collection process struggled with very large Kubernetes clusters. Millions of metrics could require tens of megabytes and tens of seconds to process every 15 seconds, forcing Datadog to reduce collection frequency. Their redesign improved collection duration by 15x and enabled more granular monitoring at scale.
## Datadog’s Kubernetes Observability Role
- The Datadog Containers team monitors Kubernetes infrastructure and ensures reliable collection of:
- Logs
- Traces
- Custom metrics
- Profiles
- Security signals
- KSM is central to Datadog products such as Kubernetes metrics integration and Orchestrator Explorer.
## How Kubernetes State Metrics Works
- KSM uses Kubernetes informers to watch objects registered with the API server.
- Enabled collectors monitor resources such as pods, nodes, deployments, and services.
- It generates lifecycle and metadata metrics in text-based OpenMetrics format.
- Users can restrict monitored resources through the `resources` flag.
- The Datadog Agent’s KSM check:
- Runs every 15 seconds.
- Discovers KSM containers.
- Crawls their `/metrics` endpoint.
- Reconciles metric metadata and applies configured label joins.
- Label joins allow metadata from one metric, such as a deployment label, to become a tag on other metrics for the same object.
## Scaling Challenges
- Datadog found that KSM needed to be split across multiple deployments beyond a few hundred nodes and thousands of pods.
- Their deployments divided collectors by resource type:
- Pods
- Nodes
- Services, deployments, jobs, persistent volumes, and other resources
- Metric volume varied substantially:
- Endpoints, jobs, and deployments produced roughly five metrics per object.
- Nodes produced around nine metrics each.
- Pods produced around 40 metrics each.
- Large clusters with thousands of nodes and tens of thousands of pods could generate millions of metrics per scrape.
- Crawling the metrics endpoint could take tens of seconds and transfer tens of megabytes.
- Datadog had to reduce check frequency, sacrificing metric granularity and user experience.
## KSM’s Original Architecture
- KSM v1 relied on a central loop that created a Builder and managed resource stores.
- Each store used informers to track a particular Kubernetes resource.
- For example, an HPA store maintained the list-and-watch logic for HorizontalPodAutoscalers.
- The Builder generated metrics from the tracked resources.
- Datadog identified two limitations:
- Too much data was emitted and processed at query time.
- The Builder did not provide a suitable extension point for custom metric-generation logic.
## Contributing the Redesign Upstream
- As the KSM community prepared version 2.0 in early 2020, Datadog saw an opportunity to address its scalability and extensibility problems in the upstream project.
- Rather than maintaining a private solution, the team contributed its findings and improvements to the open-source community.
- The resulting work reportedly reduced metric collection duration by 15x, making high-scale, more frequent collection practical.
Datadog’s experience shows that upstream open-source collaboration can solve internal infrastructure bottlenecks while improving the project for the broader Kubernetes community.
Datadog engineers discovered a significant 20–30% CPU overhead in their Akka-based Java applications caused by inefficient thread management within the `ForkJoinPool`. Through continuous profiling, the team found that irregular task flows were forcing the runtime to waste cycles constantly parking and unparking threads. By migrating bursty actors to a dispatcher with a more stable workload, they achieved a major performance gain, illustrating how high-level framework abstractions can mask low-level resource bottlenecks.
### Identifying the Performance Bottleneck
* While running A/B tests on a new log-parsing algorithm, the team noticed that expected CPU reductions did not materialize; in some cases, performance actually degraded.
* Flame graphs revealed that the application was spending a disproportionate amount of CPU time inside the `ForkJoinPool.scan()` and `Unsafe.park()` methods.
* A summary table of CPU usage by thread showed that the "work" pool was only using 1% of the CPU, while the default Akka dispatcher was the primary consumer of resources.
* The investigation narrowed the cause down to the `LatencyReportActor`, which handled latency metrics for log events.
### Analyzing the Root Cause of Thread Fluctuations
* The `ForkJoinPool` manages worker threads dynamically, calling `Unsafe.park()` to suspend idle threads and `Unsafe.unpark()` to resume them when tasks increase.
* The `LatencyReportActor` exhibited an irregular task flow, processing several hundred events in milliseconds and then remaining idle until the next second.
* Because the default dispatcher was configured to use a thread pool equal to the number of processor cores (32), the system was waking up 32 threads every second for a tiny burst of work.
* This constant cycle of waking and suspending threads created massive CPU overhead through expensive native calls to the operating system's thread scheduler.
### Implementing a Configuration-Based Fix
* The solution involved moving the `LatencyReportActor` from the default Akka dispatcher to the main "work" dispatcher.
* Because the "work" dispatcher already maintained a consistent flow of log processing tasks, the threads remained active and did not trigger the frequent park/unpark logic.
* A single-line configuration change was used to route the actor to the stable dispatcher.
* Following the change, the default dispatcher’s thread pool shrank from 32 to 2 threads, and overall service CPU usage dropped by an average of 30%.
To maintain optimal performance in applications using `ForkJoinPool` or Akka, developers should monitor the `ForkJoinPool.scan()` method; if it accounts for more than 10–15% of CPU usage, the thread pool is likely unstable. Recommendations for remediation include limiting the number of actor instances, capping the maximum threads in a pool, and utilizing task queues to buffer short spikes. The ultimate goal is to ensure a stable count of active threads and avoid the performance tax of frequent thread state transitions.
Datadog discovered that an unexpected 20–30% CPU overhead came from Akka’s use of `ForkJoinPool`, not from the log-processing code they initially suspected. Profiling showed that an actor handling intermittent latency metrics repeatedly caused worker threads to park and unpark. Moving that actor to a busier, more stable dispatcher reduced CPU usage by about 30%.
## How Profiling Revealed the Problem
- Datadog used Akka to parallelize log-event processing through actors and dispatchers.
- An optimization to log parsing produced little improvement, despite reducing parsing CPU time.
- Continuous Profiler flame graphs showed increased CPU time in:
- `ForkJoinPool.scan()`
- `Unsafe.park()`
- Thread-level analysis revealed that the default Akka dispatcher—not the expected dedicated work pool—was responsible.
- Many of the affected threads were executing a latency-reporting actor.
## Why `ForkJoinPool` Was Consuming CPU
- `ForkJoinPool` dynamically manages worker threads:
- It creates threads when work increases.
- It suspends idle threads with `Unsafe.park()`.
- It resumes them with `Unsafe.unpark()`.
- It terminates idle workers after a default period.
- The latency actor received a few hundred events per second, processed them within milliseconds, and then remained idle until the next batch.
- Because the pool allowed up to 32 threads—matching the number of processor cores—it repeatedly activated and suspended many workers.
- These frequent parking and unparking operations created short CPU spikes and excessive time in `ForkJoinPool.scan()`.
## The Dispatcher Change
- The team moved the latency actor from Akka’s default dispatcher to the main `work-dispatcher`.
- The work dispatcher already handled a steadier stream of log-processing tasks, keeping its worker threads active.
- This required only a configuration change assigning the actor to `work-dispatcher`.
- CPU usage fell by roughly 30% across services.
- The default dispatcher also shrank from 32 threads to 2, confirming that unnecessary thread activation was the cause.
## Recommendations
- Monitor CPU time spent in `ForkJoinPool.scan()`, especially when it exceeds roughly 10–15%.
- Limit the number of Akka actor instances.
- Set a suitable maximum thread count for each pool.
- Reduce the number of separate thread pools where practical.
- Use task queues to absorb frequent, short-lived workload spikes.
- Aim to keep the number of active `ForkJoinPool` workers relatively stable and avoid repeated parking and unparking.
The provided text does not contain the tech blog post itself. It consists primarily of Datadog’s navigation menu and a promotional banner announcing its “Leader” ranking in the 2026 Gartner Magic Quadrant for Observability Platforms, so the article’s argument and conclusion cannot be reliably summarized.
## Promotional Announcement
- Datadog links to a Gartner report about observability platforms.
- The banner presents Datadog as a Leader in the report.
## Datadog Product Categories
- **Infrastructure:** infrastructure, container, network, serverless, GPU, storage, and cloud-cost monitoring.
- **Applications:** APM, service monitoring, profiling, dynamic instrumentation, and agent observability.
- **Data and Logs:** database monitoring, data quality, job monitoring, log management, sensitive-data scanning, and observability pipelines.
- **Security:** code, cloud, vulnerability, compliance, SIEM, workload, and application protection.
- **Digital Experience:** browser and mobile RUM, session replay, synthetic monitoring, product analytics, and error tracking.
- **Software Delivery:** CI visibility, test optimization, code coverage, feature flags, and developer portals.
- **Service Management:** event management, incident response, SLOs, workflow automation, and case management.
- **AI:** AI agents, GPU monitoring, integrations, investigation tools, and MCP support.
The actual blog content—apparently related to how Datadog’s IT team automated monitoring of third-party accounts—is missing. A summary would require the article body or a complete excerpt.
Datadog built “Clarity,” an automated system for auditing SaaS accounts against Workday’s employee records. It regularly identifies accounts that do not belong to active employees, then logs, tickets, stores, and communicates findings through Datadog, Freshservice, Slack, and DynamoDB. The system replaces infrequent, manual reviews with continuous visibility and faster remediation of security and cost risks.
## The Need for Automated SaaS Audits
- Modern companies rely on dozens or hundreds of external applications.
- Manual account reviews are difficult to scale and may fail to detect unauthorized or abandoned accounts promptly.
- An unexpected account in an identity provider or SaaS application could give a bad actor access to sensitive systems.
- Datadog needed recurring audits as its SaaS portfolio continued to expand.
## Clarity’s Requirements
- Use a single source of truth for employee status:
- Datadog uses Workday.
- Other organizations could use Okta, OneLogin, ADP, or Active Directory.
- Run frequently enough to provide timely visibility.
- Support manual execution when needed.
- Integrate with existing communication, ticketing, and observability tools, such as Slack, Freshservice, and Datadog.
- Minimize disruption to IT workflows and encourage adoption across a globally distributed organization.
## Audit Pipeline
- A CloudWatch Event Rule triggers the audit Monday through Friday at 10 a.m. EST.
- Clarity concurrently retrieves:
- Active employees from Workday.
- Active users from primary SaaS applications such as Slack, GitHub, and Zoom.
- It compares SaaS user email addresses with active employee records.
- Accounts without a matching active employee are flagged.
- Results are:
- Sent to Datadog as logs and metrics.
- Added to DynamoDB for historical tracking.
- Converted into Freshservice tickets.
- Reported through Slack notifications with an audit summary.
## Datadog Metrics and Investigation
- Clarity sends a metric for every flagged account using the Datadog Metrics API and Python SDK.
- It uses a gauge metric to track flagged accounts over time.
- Metrics include tags such as:
- Environment, such as production.
- Responsible team.
- SaaS service.
- Flagged user’s email address.
- These tags provide the context needed to investigate the account and support alerting and visualization within Datadog.
## Practical Outcome
Clarity provides a repeatable, automated control for SaaS account governance. Organizations implementing a similar system should connect an authoritative employee directory to their SaaS inventory, run audits regularly, and integrate findings with their existing monitoring, ticketing, and notification workflows.
The supplied content does not include the blog post itself; it contains Datadog’s navigation menu and a link titled “Moving a Job System to Kubernetes.” As a result, there is not enough article text to accurately summarize its arguments, implementation details, or conclusions.
## Available Information
- The linked post appears to concern migrating a job-processing system to Kubernetes.
- The surrounding page lists Datadog products for:
- Infrastructure and Kubernetes monitoring
- Application performance monitoring
- Logs, databases, and jobs
- Security and software delivery
- No technical discussion, architecture description, challenges, or results from the post is included.
Please provide the article’s body or a working page extract for a detailed summary.
Kubernetes can improve machine management and scalability, but its scheduling and runtime overhead can significantly reduce job throughput if configured poorly. Datadog found its Kubernetes-based job system used more CPU and completed jobs 40–50% more slowly than the previous VM-based system. By designing a controlled experiment, choosing better metrics, and tuning pod resource requests, the team recovered performance to roughly VM parity while investigating the overhead of running one parent process per pod.
## Designing a Comparable Experiment
- The initial comparison was difficult because the Kubernetes and VM deployments differed in:
- Number of nodes
- Number of worker-parent clusters
- Workload and enqueue rate
- A controlled experiment was created using:
- Identical `c5.2xlarge` machines
- The same kernel version, `3.13.0-141`
- Both systems repeatedly running a simple Python job
- Each Kubernetes pod contained one parent process and its worker processes, making pod count equivalent to parent-process count per node.
- The older kernel did not include CPU mitigations, avoiding that variable in the comparison.
## Choosing Useful Performance Metrics
### Measuring node effort
- Load average initially appeared useful for measuring machine utilization.
- Kubernetes background processes—such as cluster polling and pod-state checks—artificially increased load average.
- Load average counts runnable processes rather than the amount of CPU time they actually consume.
- The team therefore used CPU idle time instead:
- It measures unused CPU capacity.
- It reflects actual CPU work rather than the number of active processes.
### Measuring system performance
- The job system optimized for throughput rather than latency.
- Throughput was measured by the number of jobs completed within 30 seconds.
- Latency remained useful for detecting queueing problems, but throughput was the primary success metric.
## Tuning Kubernetes Resource Requests
- The main performance gains came from improving pod scheduling.
- The target was six pods per `c5.2xlarge` node.
- Initially, each pod requested:
- One full CPU core
- More memory than necessary
- Since the node had eight cores and approximately 1.5 GiB of memory consumed by Kubernetes and system services, only four pods could be scheduled.
- Requests were reduced to:
- `100m` CPU, or 100 millicores
- `500 MB` memory
- CPU tuning generally enabled six pods per node, although some nodes still scheduled only five.
- Further memory reduction was needed because system daemons consumed enough memory to prevent six pods from fitting on some nodes.
- Resource requests affect scheduling minimums, while limits constrain containers after they start.
- These request changes did not slow jobs because the pods still received sufficient resources to operate.
## One Parent Process per Pod
- The team considered placing multiple parent processes in each pod to reduce potential pod overhead.
- One parent plus its workers was a natural application unit and simplified orchestration.
- The decision depended on how much overhead each pod introduced:
- High overhead would favor fewer, larger pods.
- Low overhead would favor one parent per pod for simpler management.
- Using `pstree`, the team identified six job-system instances per node and traced their process trees through components such as:
- `containerd-shim`
- `tini`
- The application process
- They estimated that each pod included overhead associated with three containers, particularly `containerd-shim`.
- CPU overhead was then investigated using `perf sched`.
The practical lesson is to compare equivalent workloads, measure actual CPU consumption rather than relying blindly on load average, and tune Kubernetes requests for the desired packing density. Resource requests should be large enough for reliable operation but not so large that they unnecessarily prevent pods from being scheduled together.
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.
Maël Nison’s journey from learning DarkBASIC on La Réunion and in Toulouse to becoming Yarn’s principal maintainer illustrates how curiosity, open source, and a focus on solving practical problems can shape a career. His early experimentation with games, websites, forums, and content-management systems developed into a lasting interest in improving developer workflows. That path eventually led through EPITECH, startups, Facebook, and Datadog, while giving him broad experience across both software and community leadership.
## Early Programming on La Réunion and in Toulouse
- Maël grew up on the remote Indian Ocean island of La Réunion, where he had little access to computers.
- After moving to Toulouse, he discovered a school programming club and began creating games with DarkBASIC.
- DarkBASIC simplified 2D and 3D Windows game development through built-in libraries, tutorials, and DirectX support.
- Seeing code immediately produce something on screen made programming feel logical and compelling to him.
- By high school, he was building PHP websites, working with SQL, and experimenting with multiple languages and platforms.
## Discovering Open Source and Workflow Automation
- In the early 2000s, distributing software was much harder because platforms such as GitHub did not yet exist.
- Maël shared source archives through online forums, reflecting the informal nature of early open source communities.
- His interest in forum software led to work on content-management systems.
- He focused on reducing repetitive administrative workflows, such as allowing users to edit content directly instead of navigating through multiple administration pages.
- This pattern—identifying a problem, building a solution, and sharing it with others—became a central theme in his career.
## Education at EPITECH
- Maël attended EPITECH in Paris, an institution centered on practical technical education and self-directed learning.
- The school emphasized peer assessment and hands-on projects rather than traditional, theory-heavy instruction.
- He also spent a year abroad in Québec.
- During his final year, he combined his studies with his first full-time job, gaining professional experience before graduation.
## Joining Facebook and Yarn
- In 2017, after several years in startups, Maël moved from France to London seeking opportunities at larger organizations.
- He joined Facebook without specifically intending to work on a package manager.
- Facebook’s onboarding “boot camp” identified his skills and connected him with the emerging Yarn project.
- He welcomed the opportunity to work on open source during his regular working hours.
- What began as a few pull requests became a multi-year role as a major maintainer and leader of the project.
## Yarn’s Technical and Community Evolution
- Yarn was rewritten in TypeScript and re-architected into a more modular system.
- It evolved from an internal Facebook tool into a genuinely community-driven open source project.
- Maël’s responsibilities expanded far beyond coding:
- Product management and roadmap planning
- Team leadership and infrastructure
- Customer support and community work
- Web design, evangelism, and outreach
- Defining the project’s broader vision
- Although he left Facebook for Datadog in 2019, he continued leading Yarn while taking on new challenges at Datadog.
Maël’s experience suggests that careers can grow from small, self-directed experiments into major technical leadership opportunities. Developers can follow a similar path by solving concrete problems, sharing their work openly, and being willing to take on the technical, organizational, and community responsibilities that accompany successful projects.
PHP’s observability mechanisms failed to keep pace with Zend Engine improvements in PHP 7 and PHP 8, especially the introduction of JIT. Existing hooks imposed significant runtime costs, created compatibility and stability problems, and limited tracers such as Datadog’s ability to evolve. PHP 8 addressed these issues by introducing a new observer API designed specifically for modern, lower-overhead runtime instrumentation.
## Observability Before PHP 8
### The `zend_execute_ex` VM Hook
- Extensions could override `zend_execute_ex` to intercept every PHP-defined function and method call.
- This moved PHP calls onto the native C stack, whose limited size (`ulimit -s`) could cause stack overflows and process crashes.
- Every userland call was intercepted, even when an extension only needed to observe a subset, adding overhead to call-heavy applications.
- The compiler could no longer use optimized distinctions between userland and internal calls, such as `DO_UCALL` and `DO_ICALL`.
- Extensions had to manually forward the hook to other extensions, creating “noisy neighbor” problems, unexpected behavior, and possible crashes.
- The hook was incompatible with PHP 8’s JIT compiler.
### Custom Opcode Handlers
- Extensions could replace handlers for function-call opcodes, avoiding the native-stack problem associated with `zend_execute_ex`.
- These handlers still required careful forwarding to neighboring extensions, which was historically unreliable.
- Handlers could mutate VM state—for example, preventing the original opcode from running—making reliable cooperation between multiple extensions impossible in some cases.
- Generators could not be fully instrumented through custom opcode handlers.
- Like `zend_execute_ex`, custom opcode handlers were incompatible with the PHP 8 JIT.
### Zend Extension Hooks
- Zend Extensions had privileged access to engine-level function-call begin and end handlers.
- This approach caused the compiler to emit `EXT_FCALL_BEGIN` and `EXT_FCALL_END` around every function call.
- The additional opcodes introduced too much overhead for production-grade tracing.
### AST Injection Experiments
- Researchers explored injecting observability nodes into the abstract syntax tree during compilation.
- These nodes could invoke tracing functions before and after calls.
- However, injecting instrumentation around every function call was expected to have overhead comparable to Zend Extension hooks.
- No production-ready tracers using this approach were known at the time.
## The Need for a New Observer API
- Existing hooks forced observability tools to interfere deeply with VM execution or compiler output.
- Their limitations included excessive overhead, stack-safety risks, incomplete generator support, extension conflicts, and JIT incompatibility.
- These constraints prevented tools such as the Datadog PHP tracer from taking full advantage of PHP 8.
- In response, the authors and the PHP internals community developed and shipped the observer API in PHP 8, providing a foundation for more modern and efficient tracing, profiling, and debugging.
PHP 8’s observer API was necessary because older instrumentation techniques were either unsafe, too slow for production, difficult to compose, or incompatible with the JIT. A runtime-level observability mechanism designed alongside the engine is a more sustainable approach than modifying VM hooks, opcodes, or compiled syntax from extensions.
