In my previous article about CVEs, we looked at CVE growth. But we didn’t look at the time between detecting a vulnerability and identifying an exploit. The concern is that AI is accelerating not only the number of CVEs and patches, but also exploit creation, shortening the time between a CVE being reported and an exploit becoming available.
The overall trend shouldn’t come as a surprise. Although the spikiness of the data wasn’t so expected. There are a couple of possible explanations for this:
New exploits occurring that have then been attributed to older CVEs. In some respects, the shrinking fluctuation range says a lot as well; after all, as we find more vulnerabilities, the chances of exploits being linked to a more recent issue increase. Furthermore, if you’re using CVEs to find possible exploits to leverage, a more recent one is better, as targets are more likely to be unpatched.
The volume of data points is lower, so the median is more easily influenced by outliers.
To be transparent, we sourced the underlying data for this graph from a public GitHub repo that curates data from a range of trustworthy sources, from the FBI to CVE.org (more details here). The data also supports vulnerabilitydata.io, which asks big questions like how AI is impacting society.
The plot uses a published monthly dataset that joins CISA’s dateAdded to the official CVE record’s datePublished, groups records by KEV addition month, and excludes CVEs published before KEV launched. Its October 2026 value is partial, based on data fetched on 26 October 2026.
Other data sources
While we’re looking for data, the following sources came up as potentially interesting.
CVE publication → its earliest recorded exploitation evidence or KEV addition
Annual analyses and record-level data; no verified public monthly aggregate here.
Medium, conditional on access and the evidence behind each record. Its published example calculates intervals from NVD publication to VulnCheck KEV addition. Vulnerability Research
CVE publication → first dated public exploit or PoC evidence
No verified comprehensive monthly aggregate; join and deduplicate individual records.
Medium to low. A listing or sighting can lag the code’s first publication, and a public PoC does not establish exploitation in the wild. CIRCL explicitly distinguishes these event types. exploit-db.com
Daily changes in predicted exploitation probability
Daily historical scores, but not a date of exploitation or PoC publication.
High for what the score said on a given day; unsuitable as the endpoint for the requested delay. Model changes also affect comparisons across years. first.org
Conclusion
Regardless of the vulnerability, and an organizations approach to being secure, be that:
Patching as fast as possible.
Establish a robust security architecture that provides strong (compensating) controls. In other words, remove or reduce the ability for someone to exploit a vulnerability to a level where the patch cost-benefit formula doesn’t pay.
We need to evaluate the likelihood of exposure as soon as the CVEs are published.
When it comes to application observability, it is easy to lose sight of the challenges of tracking how our data flows in and out of the database. Considerations include query performance as the database sees it, when SQL gets held up or fails because of database locks, and database calls that get rejected for various reasons such as privileges (particularly when joining data sets). How impactful these things can be is dependent upon how the application is built, and where the weight of data manipulation resides. For example, a multi-tiered application that uses object-relational mapping frameworks such as Hibernate (Java), Gorm (Go), SQLAlchemy (Python), or tracing methods (even if you don’t instrument the libraries) lets you infer and extrapolate database performance details. However, retrieving the explicit information is always better. But for other solutions, such as ERPs like E-Business Suite and parts of General Dynamics where the business logic is within the database as stored procedures, the ability to extract more detail from the database is going to be needed.
This means our observability agent needs to formulate, execute, and transform the results of SQL queries. This leads us to:
Ideally, plugins that understand how to access the relevant database data and retrieve it in a consumable manner will make the process easier. In other words, having pre-canned logic or configuration that understands how to retrieve core metrics like slow queries is desirable.
Having the ability to run SQL is also freeing, as it allows for application-specific queries to also be incorporated and retrieve metrics and details from where stored procedures have recorded logs. For example, one of Oracle’s IdM products records its logs in a table (see here).
If we can query the database, caching or pooling connections is highly beneficial, since establishing a connection is costly and we don’t want to incur that cost every time we need to execute the queries. We also don’t want to leak connections or rely on the database’s connection manager to decide that connections have been inactive and to reclaim them.
This leads us to ideally having three capabilities:
Pre-canned queries for mainstream database technologies
Ability to add custom queries
Ability to pool connections
Capability matrix
The following shows which observability tools can work with which databases, the nature of the query capabilities and the ability to cache. For full transparency, I am not an expert in every one of these products, so I used AI to help with the analysis. That said, I have checked what the AI has pointed to.
The language used is explicitly defined below the table if you need to confirm it. The one variation is Fluent Bit, which doesn’t provide an out-of-the-box query-related plugin, but we can use Lua for a script that can work with any database.
Both — predefined monitoring queries and configurable SQL queries are available, potentially through separate plugins.
Config — supports user-defined SQL queries.
Predefined — built-in database metrics or fixed queries, without needing general-purpose SQL configuration.
Limited — partial functionality, such as incremental table polling.
— — no native database-querying capability established.
Pool ✓ — connection reuse/pooling is explicitly documented.
Pool? — connection reuse is not sufficiently established by documentation.
Pool n/a — no native database query connection.
Important qualifications
OpenTelemetry: A Both designation can represent the combination of the generic sqlquery receiver and a separate database-specific receiver. Connection pooling is documented, but controls differ between receivers. The generic SQL receiver exposes max_open_conn; certain specialized receivers offer more extensive pooling controls.
Telegraf: Its generic SQL input supports configurable pooling using maximum open and idle connections, maximum idle time and connection lifetime. Its database-specific plugins provide additional predefined monitoring capabilities.
Grafana Alloy: Oracle is a particularly strong option because its exporter explicitly documents max_idle_conns, max_open_conns, predefined metrics and custom metric definitions. Equivalent pooling guarantees have not been established for all other embedded exporters.
Logstash: JDBC connection pooling is supported, but you generally need to install the database-specific JDBC driver separately. Its SQL input produces events rather than directly modelling each result as an OpenTelemetry metric.
Metricbeat: Both means its database-specific metric sets can be combined with its generic SQL module. This does not mean that the generic SQL module itself provides predefined slow-query statements.
Vector, Fluentd and Fluent Bit: Their narrower entries are significant. Vector has native database-specific metrics inputs, Fluentd’s SQL plugin focuses on incremental record ingestion, and Fluent Bit requires database connectivity through a Lua script.
Additional resources
What is clear is that the number of observability agents that provide built-in understanding of databases is limited, and that you need to provide configuration for the queries – which is understandable; if you’re able to at least enable user-defined queries, the user can research how to retrieve data like slow queries. To that end, we’ve started compiling some documents that identify queries that will help for that database. You can find the documentation for the tooling we’re putting together to simplify creating an end-to-end pipeline in GitHub (https://github.com/opamp-observe/config-generator/tree/main/docs/db-query-analysis).
Alternate Strategies
Obviously, we’ve taken an observability agent lead approach, as this means that the data is immediately being routed onwards to where it needs to be. But this polling, while some metrics need to be counts per interval, not all data needs to be that way, and as any integration person will tell you, being event-driven or pushing (as long as we’re not creating unnecessary additional latency in a process) is desirable. This points to: do the databases have built-in push mechanisms?
Built-in in OLTP emitters
In a perfect world, databases would make all their information available through OTLP, including allowing applications to provide additional metadata for application-level logs, metrics and traces. Today, there is varying support for built-in OTLP payload emission, as the following table shows:
Database
What can be sent to an OTLP endpoint?
What can be tailored?
Oracle
Oracle AI Database 26ai can export database observability logs associated with traces. For metrics, Oracle’s separate Oracle AI Database Metrics Exporter publishes metrics over OTLP/gRPC. It can also export the alert log as JSON for a log aggregator. docs.oracle.com
The exporter lets you define custom metrics in YAML or TOML and set collection intervals and query timeouts. Native observability has configurable endpoints and service options. oracle.github.io
PostgreSQL
PostgreSQL has no built-in OTLP metrics exporter in the sources reviewed. The open-source pg_otel module can send server log messages to an OTLP endpoint. For metrics, the OpenTelemetry Collector can query PostgreSQL’s statistics. github.com
pg_otel lets you set the endpoint and resource attributes. The Collector receiver lets you select metrics; its SQL Query Receiver can turn custom query results into metrics or logs. github.com
MySQL
MySQL’s telemetry component supports OTLP metrics export. Its supplied log exporter sends OTLP logs, but requires MySQL Enterprise Edition or HeatWave; the logging interface alone does not provide an exporter. dev.mysql.com Other vendor-supported variants of MySQL also support OTLP, such as Percona Server for MySQL 9.7
Configure the signal endpoints and protocols, then enable or disable meters and loggers. Logging support depends on edition. dev.mysql.com
MariaDB
No built-in server OTLP exporter was identified. The OpenTelemetry Collector’s MySQL receiver can collect metrics from MySQL and MariaDB servers. You can collect them separately or map query results to log records. github.com
The Collector can select metrics or use custom SQL queries and map their results to metrics or logs. github.com
SQL Server
No built-in server OTLP exporter was identified. The OpenTelemetry Collector’s SQL Server receiver connects to the database to collect metrics; log files or selected query results can be collected separately. github.com
Configure which receiver metrics are emitted, or use custom SQL queries and signal mappings in the Collector. github.com
ClickHouse
No built-in server exporter for OTLP metrics or logs was identified. A Collector can query ClickHouse, read its log files, and forward the results to an OTLP endpoint. github.com
The Collector’s SQL Query Receiver supports custom queries, collection intervals, and mappings from query results to metrics or logs. github.com
MongoDB
MongoDB Ops Manager’s Agent can push monitored metrics to an OTLP/HTTP endpoint. MongoDB Atlas can export selected system and audit logs to OTLP endpoints. These exports are provided by MongoDB’s management services, rather than by the database process itself. www.mongodb.com
Ops Manager lets you configure the endpoint and export cadence. Atlas lets you choose log types and configure up to 10 destinations. For self-managed MongoDB, the Collector can query metrics and collect query-related events. www.mongodb.com
While some databases don’t yet provide support for this, it is likely to become the norm. For example, key members of the PostgreSQL ecosystem, Craig Ringer and Gabriele Bartolini, are actively advocating the native adoption of OTel (see here). Other database solutions we’ve found that include OTLP support include Databricks Lakebase (a managed DB built on Postgres) and SurrealDB.
File Staging
Where there aren’t built-in OTLP capabilities, another approach is to incorporate stored procedures that can write to an externally visible temporary file location. Then the observability tool can use file tailing plugins to ingest the data into the observability pipeline. This means we should take a look at what databases offer in this direction:
Database
Stored procedure ability to write to an external filesystem?
Can it run SQL on a schedule?
Oracle
Yes. PL/SQL can use UTL_FILE to write files in permitted directories. For a remote host, DBMS_SCHEDULER.PUT_FILE can transfer files using a Scheduler agent.
Yes, with elevated access. A procedure written in an untrusted language such as PL/Python can access operating-system resources. SQL COPY can also write a server-side file, but requires superuser rights or the pg_write_server_files role.
Yes, with an extension or external scheduler. PostgreSQL has no built-in general job scheduler; pg_cron is a widely used extension that runs scheduled SQL inside the database. Python Procedural Language
MySQL
Yes. A stored program can use SELECT ... INTO OUTFILE to write query results on the server host. The FILE privilege is required, and secure_file_priv can restrict the permitted directory.
Yes. The built-in Event Scheduler runs scheduled SQL events; an event can also call a stored procedure. dev.mysql.com
MariaDB
Yes.SELECT ... INTO OUTFILE writes query results to a server-side file. As with MySQL, the database service account must be able to write to the destination.
Yes. MariaDB’s built-in Event Scheduler runs scheduled SQL, including calls to stored procedures. mariadb.com
SQL Server
Yes, through privileged features. A stored procedure can invoke xp_cmdshell to run an operating-system command, or use CLR code with external access. xp_cmdshell is disabled by default.
Yes.SQL Server Agent schedules jobs with T-SQL steps, including calls to stored procedures. The Agent service is disabled by default on a new installation. Microsoft Learn
ClickHouse
No stored-procedure mechanism in the usual sense. ClickHouse does support executable user-defined functions: a query can invoke an external script, which could write files if the script and server account have permission. That is external code execution, not a stored procedure.
No general database-side stored procedure with access to the database host’s filesystem. MongoDB server-side JavaScript features are not equivalent to operating-system procedures and are deprecated starting in MongoDB 8.0. Atlas Functions run in a separate managed runtime, not in the database process.
Not SQL: MongoDB Atlas Scheduled Triggers can run server-side functions on a schedule. For self-managed MongoDB, you generally handle scheduling externally.
Conclusion – Understanding what to retrieve
So, there are several different strategies that can be pursued to monitor a database: several different strategies can
Observability plugin
DB-variety aware.
Generic connector options, but configuration must provide context for the DB type.
Databases can push or be scraped for telemetry.
The database can externalize data that can then be picked up by the observability tool using mechanisms such as file tailing.
What is clear is that most options require a good understanding of what to retrieve from the database. As a result, to support our work on automating pipeline creation, we have captured documents that bring together recommended practices for what data to retrieve and how to do so, and compiled the information as documents in the repository.
When I wrote Logging In Action, I found that to help with setting up and testing logging pipelines, having a utility that could just take existing logs and play them so it looked like a real application was generating the logs was helpful – not only for the book, but in everyday work.
The natural evolution was: can I also create and run synthetic logs through observability systems so we can ensure log thresholds, filters, alerts, etc. worked as expected. Not to mention taking synthetic or real logs and applying some basic reformatting so we could mimic Apache or Nginx web servers, for example.
So the LogGenerator (sometimes called Log Simulator) was born and made available. At the time, my development skills were centred on Java (and I loved Groovy for its convenience and development speed). So we built the solution using Groovy and Java -the net result is that you could create a deployable JAR or run it without the need to first establish a Maven pipeline (without sacrificing the ability to keep polymorphism and abstract layers).
The LogGenerator has had a number of enhancements, so we could use it to check not only tools like Fluentd and Fluent Bit, but also cloud observability tooling such as OCI. This was made to be a pluggable framework so you could add custom targets easily.
Time moves on …
Python continues to grow in popularity and is the default language bundled with Linux. I’m comfortable developing in Python now, and we have the tools I enjoyed with Groovy and Java (no need to mess with build pipelines for quick changes, but it can also be packaged and easily deployed for mainstream adoption).
But it isn’t programming language evolution that has triggered change. OpenTelemetry standards and the golden signals of Logs, Traces and Metrics are the norm. So applying the same principles to the Traces and metrics that the LogGenerator used for logs is a natural evolution.
Deployment
It was pointed out to me that, even if people don’t take the full OpAMP solution we built, the simulator component may be attractive in its own right. This got us to thinking about whether there was value in pairing the SignalGenerator with the OpAMP simulator.
As a result, we created an optional feature that lets us deploy SignalGenerator as an extension of the OpAMP simulator. This gives us multiple deployment options.
A free-standing solution in its own right, with no need for anything else. Ideal for dropping into test environments to exercise your Observability configuration and tuning without needing start-up applications that require large deployments with complex inputs to generate unhappy path signals.
Deploy in a supervised manner using OpAMP – ideal if you want to drive synthetic Observability exercises in a distributed manner.
Plug into the OpAMP simulator – fewer processes running, easier to create custom commands through the OpAMP framework to get the generator to do things from pushing out new data sources to be replayed, to having signal generators simulate Observability data that reflects a distributed cascading failure as means to evaluate smarter AI-driven processes that should be looking for correlations and cause and effect.
The last part with custom messaging over OpAMP is not yet in place, but it’s a candidate for enhancement.
New home
As the Logging in Action book uses the LogGenerator, we didn’t want to make this level of change in the current repository. So we have a new repository within the OpAMP-Observe GitHub organization which has feature parity, but also has a mechanism for simulating metrics (pushing, or allowing the data to be scraped).
The documentation to link the repositories and the GitHub documentation together is a little bit behind, and we need to figure out how to create a manageable playback structure for Traces before we enable that feature.
In our first post on Moving Open-Source Observability closer to turn-key solutions, we discussed how we can automate the source-to-pipeline. But turn-key solutions also flow data to the backend and provide logs and metrics that are contextually aware of the systems being monitored.
While detecting sources and building the capture mechanism may seem more challenging at first glance, it is easier – we have a defined technology, and our observability agent defines the output structure. So what makes the pipeline to the backend more complex?
We’re more likely to have a variety of products, and some products may have functional overlaps.
Greater configuration diversity in how tools can be configured.
Greater contextual awareness is needed.
Let’s break these down in more detail.
Greater variety of tools means we need a common way to set up transformations; otherwise, the mechanics of a transformation process in our pipeline will explode in complexity.
One benefit of going open source is that you can choose the tools that fit your needs for log analytics, metrics, alert routing, and so on, but this can lead to functional overlaps. For example, you may use Prometheus for infrastructure-based metrics, but want to use Elastic APM for Application Performance Management (APM) as you’re using an Elastic Java stack for app development.
The different approaches to configuring tools, or configuration diversity, is probably the single largest challenge, and the number of approaches multiplies the number of configuration permutations that must be achievable. While there appears to be some initia behind the support the Prometheus mixin framework which provides templates for different scenarios such as infrastructure dashboards and alerts. It is far from universal adoption today. For example, Prometheus and Grafana support its use. But other solution stacks such as Elastic do not. If you align on a common technology stack, the chances of a harmonised configuration process rise.
We need contextual awareness from the source, as well as the collected data, to map data to the table(s). For efficiency, if we can avoid putting all metrics into a single table, queries could have one less dimension to filter. Context awareness will inform how we render the dashboards and set alert thresholds. For example, general filesystem storage capacity thresholds would be hugely different to database storage thresholds.
All of this means that if we want a deterministic, transformation-based process, we’ll end up with an unsustainable set of combinations that need to be mappable, testable, and maintainable as the different solutions grow, evolve, and occasionally get archived as contributions dry up.
As turnkey solutions, bring an opinionated answer and either build their own backends from scratch (e.g. Oracle’s Enterprise Manager) and leveraging open source as building blocks – they effectively eliminate the challenges of functional overlaps and configuration diversity – at the same time removing that flexibility. To underline how messy things could get, we experimented in a branch of the repo to see how messy it could get, while trying to keep the divergence as narrow as possible. This diagram illustrates the point visually.
Solution
If a deterministic approach is unsustainable, are there options to ease the challenge or achieve a solution?
Simplification option
One option that can simplify, but certainly doesn’t solve, the challenge is to leverage OpenTelemetry’s work on semantic conventions, where they have been cultivating naming conventions that define data elements likely to be transmitted. When you manually map data, the process becomes more intuitive (and therefore quicker) and improves the chances of an AI agent mapping successfully. In some respects, this is like middleware-driven efforts to build data ontologies, so you need to avoid the problems global ontologies had.
Bringing AI to the game
Because configuration is linguistic and well documented, you can apply an LLM-based approach to the problem. The process of mapping from the ingestion part of the pipeline to the back end needs to be flow-driven so we can:
Perform a validation process by selecting and using validation tools to verify the configuration(s).
When validations fail, the process can be pushed back to the configuration stage again.
When users are in the loop, it becomes possible to drive a conversation for more clarity.
With a conversational process, it becomes possible to create in-pipeline transforms as a result of user conversation, along with simpler transforms to handle possible data formats and names.
What we’re describing here isn’t trivial, and could arguably be offered as a commercial product in its own right. The config management feature of our OpAMP solution also provides meaningful inputs, as it defines valid data types for observability agents like Fluent Bit where a concrete schema is not provided.
Using AI – agent graph
Agent descriptions
The agentic process illustrated in the preceding diagram is not trivial. It will be pretty context-heavy, as much of the information to work with can’t be easily addressed through targeted RAG or semantic search. In most cases, these core agents will need tools such as web search, since their training isn’t as up to date as the latest features of the different tools.
Input evaluator – We need a variety of inputs covering the target systems and, if there is overlap in capability, guidance on which ones to use. We need to tell the agent what tooling the pipeline needs. We’ll likely need metadata on the sources. For example, if we detect a database, we need to know which type so we can inject the correct queries. The input evaluator will use this to decide whether the detail is sufficient. The result of this analysis could be one of several things:
Use a client conversational agent that chats with the user to get clarifications; there is some overlap here, as the conversation will need to know what answers are needed, and some answers may open up new questions. Once this agent believes it has compiled the details for the answers. it returns to the Input Evaluator to reassess the picture.
We can ask the evaluator to pause the process and generate a report showing the gaps identified. This can be done using the Clarifications Report generator.
The Input evaluator may determine that it reports the gaps and presses on with a best effort.
Semantic normalizer – To simplify the flow, mapping source names to the semantic definitions from OpenTelemetry would need to understand the source and the OTel Semantic Naming model.
Pipeline generator – Once we confirm the details and have simplified semantics, we can have the AI build out the rest of the pipeline. The agent may need to be handed back to the agent for correction.
Config validator – once the pipeline generator hands off the configurations, the validator agent determines the best tools to verify whether the configurations are valid. If the tool returns an error, it hands the cause back to the pipeline generator. Ideally, tool calls will return meaningful error descriptions. But if not, we’d need to create a simple knowledge base to extract details from.
Clarifications Report generator – The clarifications report generator’s role is to take the gaps identified and generate and share them via a document repository or email in a user-friendly format
User clarification – The conversational interface with the user to obtain missing details, according to the Input evaluator. One difference between this and the Input evaluator is that this agent will need to consider conversational history to build the required additional detail. The input evaluator shouldn’t need prompting.
Controlling complexity
We’ve seen that allowing flexibility and removing the opinionated constraints of turnkey solutions increases complexity very quickly. The AI solution will become much more reliable if we strip back the options we allow agents to choose from, or if we push more organizations to standardize on consistent configuration strategies that enable a move toward templatization.
A Unified pipeline syntax
The other path that could radically simplify things is the Open Telemetry Transformation Language (OTTL), which has just reached the version 1 milestone. While it is not a complete solution, it offers a way to advance the standardized pipelines. We’ll explore OTTL in a separate blog in more depth. But essentially, if you look at the collector as two parts- the wire-level mechanism to capture or emit data and a second part for routing and manipulation- then OTTL is about the routing and manipulation. OTTL has both a formal syntax and an implementation as a Go library. While the library may not help if you’re using Vector, Fluentd, Fluent Bit, etc., the formal notation will work with ANTLR4; the resources are available through the OTLery OTTL-Lang repo. This allows us to generate, across many languages (C, Java, Ruby, Lua, etc.), a parser for the OTTL syntax into a tree structure that can then be walked. This still needs the intelligence to translate data references into references for the observability tool, and the functions, editors, and transformers to be implemented. Still, most of these can be mapped onto language-native libraries.
With a formal notation and a growing catalogue of prepared OTTL scripts and utilities, such as those offered by the OTLery repos, there is the ability to leverage AI to generate the transformation logic. As many observability tools such as Fluent Bit and Vector include support for scripting and plugins, incorporating a complete parser becomes a practical option. With both Vector and Fluent Bit, for example, supporting Lua being incorporated into the pipeline, and ANTLR4 supporting Lua as well, it should be possible to implement OTTL in those pipelines.
There is one downside to using OTTL: we lower our observability agents to the lowest common denominator. For example, Fluent Bit provides basic stream analytics. Transformations are now going through a parser phase rather than going directly to native binary processes.
Conclusion
The more we can restrict options, the closer we can get to being able to automate the creation of the observability pipeline quickly, and efficiently, but at the price of potentially not maximizing feature exploitation (the downside of using OTTL across different observability agents). The problem is to provide a solution that is very flexible, which will require a fair bit of effort. That flexibility also creates the possibility of exploiting the full feature set of the available tools.
With the explosion in the number of CVEs (Common Vulnerabilities and Exposures) being published, it begs the question as to whether the number of Known Exploited Vulnerabilities (KEV) is trending in the same direction. The natural assumption would be that there be some level of correlation. It took some exploring of data before we started to see any data trends that made sense, and threw up some interesting observations.
Before we look at what we might be able to infer from the data and the patterns we see, let’s start with the looking at the data we’ve sourced and plotted.
Data sources
CVE Publications — CRACI / CVE Program: Monthly counts of published Common Vulnerabilities and Exposures (CVEs), categorized by CVSS severity: Critical, High, Medium, Low and Unknown. The data originates from the CVE Program’s official records and is presented as stacked areas to illustrate changes in vulnerability volumes and severity distribution over time. Sources: CRACI CVE Publication Trends | CVE Program GitHub.
CISA Known Exploited Vulnerabilities (KEV): Monthly counts of vulnerabilities added to the US Cybersecurity and Infrastructure Security Agency’s catalogue of vulnerabilities confirmed to have been exploited in the wild. Counts are based on the date vulnerabilities entered the catalogue rather than when exploitation first occurred. Presented as the red line. Sources: CISA KEV Catalogue | CISA KEV GitHub.
CIRCL Vulnerability-Lookup: Monthly deduplicated counts of vulnerabilities recorded across multiple exploitation intelligence catalogues, including CISA, Shadowserver, ENISA, Previdian and CIRCL. By aggregating these sources, it provides broader visibility of known exploitation than any individual catalogue, although counts reflect when vulnerabilities were listed rather than necessarily first exploited. Presented as the purple line. Sources: CIRCL Vulnerability-Lookup | GitHub Repository.
VulnCheck KEV: Monthly counts of vulnerabilities identified as exploited in the wild through intelligence collected from security researchers, vendors, incident investigations and other publicly available evidence. VulnCheck provides an additional perspective beyond CISA, although its reporting volumes may be influenced by changes in intelligence coverage and retrospective discoveries. Presented as the thinner teal line, with the monthly figures currently treated as provisional pending independent validation. Sources: VulnCheck | Exploit Intelligence Documentation.
Understanding the data
Spikes in KEV data and varying sources
We have seen (and it is visible in our graph that the different sources of KEV data tend to show early spikes, typically triggered when the catalogue is being populated with retrospective data. We initially started looking at individual reporting sources such as VulnCheck thinking that they would give a true figure and the aggregated reporting data such as CIRCL would provide amplified patterns. The opposite appeared to be the case. We’ve kept the VulnCheck and CISA KEV reporting help illustrate this. Where Vulncheck’s spiking tend to be dramatic compared where CIRCL might show a small uptick, but then in the last quarter of 2025 we start to see opposing trends. It appears that CIRCL’s aggregation of sources has smoothed out the fluctuations. CISA’s KEV numbers in comparison a notably different in volume to VulnCheck. The CISA numbers generally follow the same pattern as CIRCL until 2026 – with the worst divergence 50 exploitations identified rather than the triple digit variance of VulnCheck.
Critical and High CVE fluctuations
If you look carefully and the CVE trends in the different categories, while there is clearly an acceleration in the last 12 months (which we could attribute to initiatives such as GlassWing) if you look carefully, you’ll notice that the growth in Severe and High scoring CVEs is growing faster. It is only two dates, but this table supports the observation:
Severity
September 2025
September 2026
Growth
Critical
295
1,555
+427%
High
1,275
6,160
+383%
Medium
2,331
5,285
+127%
Low
148
564
+281%
Unknown
263
1,366
+419%
Total
4,312
14,930
+246%
The telling difference is if you compare the total growth against the growth numbers and the individual severity growth numbers. The critical numbers have multiplied by nearly 1.75.
Exploits (KEV) appear to be tracking vulnerabilities (CVE)
Perhaps the most important, point in the data is that based on the aggregated CIRCL counts, exploits are following the upward trend with a bit of lag which fits what thought we’d see. Yes at this point we’re are mindful that this could be finding data that supports a hypothesis (particularly given other individual KEV numbers may not support the trend). But on balance I’m inclined to trust the CIRCL numbers because if other numbers are erratic we’d not see such a similar upward track.
How is patching performance responding?
Keeping up with patching is likely to prove challenging, the 2026 Edgescan report picks out a rather telling observation, which supports the problems of not keeping up:
The most striking insight is that vulnerabilities from 2025, 2023, and 2024 account for more than 50% of all occurrences, indicating that newly published or recently discovered issues are the primary drivers of risk this year.
The suggestion is that the really high profile vulnerabilities get addressed, but the progress to address those that don’t get the notoriety is weaker. The alternative possibility relates not on individual exposures but when failures grab the headlines that attention turns back to patching. Another indicator that patching can’t keep up is the Verizon 2026 DBIR reported 26% of CISA KEV vulnerabilities fully remediated in its analyzed population versus 38% in the prior report, with median full remediation time increasing from 32 to 43 days (assuming Verizon’s dataset is representative).
Conclusion
While this is not an exhaustive analysis, it would be fair to treat it as anecdotal evidence to indicate:
CVE acceleration is being followed by KEV acceleration – possibly the most concerning.
If historic data shows we can’t keep up with patching, then its only going to get worse – supporting the expectation of climbing KEVs.
We do therefore need to look to adopt differing strategies to protect ourselves, and new measurements to reflect whether the new approaches are paying dividends. So what can we do differently, and I’m not saying don’t patch, I’m saying if you have a finite patching capacity, use it wisely, and invest in actions that give you the best vulnerability reduction.
Steps
Patching is by its very nature after the horse has bolted, this is why we have zero day exploits. The bottom line is there will always be vulnerabilities, the question is who finds them first and how do we react. Perhaps an exceptional illustration is the Apollo 11 Guidance Computer 1201 and 1202 errors (more about this and other aspects of the Apollo program at Apollo 11 Journals, the BBC also have an excellent podcast – 13 Minutes to the Moon that broke this down). This essentially was a memory overload error (should sound familiar as it is an attack vector, only difference is the overload was innocent for Apollo 11). The lesson is, the ground crew had encountered various issues during training, so put operational processes in place to allow them to quickly determine cause and action. Just as with modern businesses, the lunar programme could not be stopped to create months to rework Apollo’s software to avoid the issue, so they ensured there are what we might call compensating controls – a manual ground crew process that could tell Armstrong and aldrin what to do.
Continuing compensating controls, is not to have reactions ready, but also preventing attacks from reaching vulnerabilities. For example Oracle’s WebLogic Server has some CVEs around its T3 protocol. If you’re not using this as a communication channel between severs you can switch it off in the configuration. Better still, put those servers within a subnet with network security rules that prevent T3 traffic from getting into the subnet. There are multiple CVEs for T3 – so rather than patching everyone one of them, you’ve prevented the exploit from being usable by anyone other than someone having been able to get into that subnet.
The next upside of such a control is that even if the T3 vulnerability was exploited, the ‘blast radius’ is constrained, as the network configuration will make it a lot harder to move to other servers as first they need to find away to see beyond the local network. This brings another philosophical change which doesn’t have to be difficult to achieve. We always look at security on the inbound traffic – but we should be just as observant about outbound paths, and have controls. One very contemporary aspect of this is to put gateways between applications or agents and LLMs. The focus is that credentials to external tools and services are only introduced beyond the sphere of the LLM(s). But we can also prevent the LLM from being hijacked into abusing tools (from the LLM view point it is an inbound security control). But we should treat all outbound data this way. Its the fastest way to detect and stop data egress.
It doesn’t need a chaos monkey but …
Many will have over the years heard about the development of the chaos monkey at Netflix by Greg Orzell which is a small app that can be unleashed and will try to tear everything up. While this maybe seen as rather extreme, the underlying message is once its secured, don’t assume it remains secure (controls can be accidentally removed). Put basic security probes into the environment – you can test non-destructively. Don’t put a procedure in place and let is rot on a shelf, if you have capacity – fail things over. The more these sorts of processes a run, the more it becomes ‘muscle memory’ and while early iterations will be painful, that pain and cost will be minor to when it happens for real.
It isn’t if, but when …
We all like to think these things won’t happen to us, and we’re prepared. But worldwide 1 in 5 will have cancer in their lifetime. Many cancers are treatable, and largely routine – because the medical profession have had to treat the problem over and over. We just have to see IT attacks in the same manner.
Most engineers are probably aware of the shortening life span of TLS certificates. this year certificate maximum life drops from 398 to 200 days. But what may not have registered is that the roadmap sees the max certificate time will continue to half every year. This means that by 2029 certificate lifecycle will be down to 47 days (31 days (core duration) + core duration/2 days + 1 day). But before 2029, in less than six months we’ll see the current certificate durations half from 200 to 100 days. As with the 2026 change, the new limits come into effect on the 15th March. Which does create an odd situation where certificates issued on the 14th March will outlast certificates issued on the following day.
The addition of half the core duration period is to allow for the recovery from failures. as of 2029 the expectation is every month the certificates should be rotated.
Manual processes are unsustainable
This means that the rotation of certificates has got to be accelerated to be monthly, a velocity that is simply not practical to be done by hand. This means the deployment of certificates really needs to be automated. There are a number of frameworks and standards that support the distribution of certificates.
Perhaps the best known and leading solution has been ACME protocol working in conjunction with Let’s Encrypt CA. The least known is the use of OpAMP also supports certificate distribution. The following table shows the different standards that specifically address certificate management (CLM), some implementations are linked to a Certificate authority , others are not.
Commercial implementations are less prominent; verify explicit CMC support and supported operations with individual PKI vendors
To understand the differences between the different standards, it is worth looking at the standards from the perspective of the operations that are needed to manage certificates.
Function
ACME
CMP
EST
SCEP
Vendor CLM API
Certificate issuance
Yes
Yes
Yes
Yes
Usually
Certificate renewal
Yes
Yes
Yes
Yes
Usually
Certificate revocation
Yes
Yes
No native operation
Limited
Usually
CA certificate rollover
Limited
Yes
Yes
Limited
Varies
Central certificate inventory
No
No
No
No
Usually
Ownership / application mapping
No
No
No
No
Varies
Policy management
Limited
Limited
Limited
Limited
Usually
Application deployment
No
No
No
No
Vendor-specific
Application activation
No
No
No
No
Through integrations
Deployment verification
No
No
No
No
Varies
You’ll note that the deployment, activation and verification steps fall into the domain of vendor solutions, and are variable. However we can address such considerations in an open-source (or commercial) manner through tooling such as Puppet, Chef and certain payload types provided by OpAMP.
These CLM options aren’t the end of the story as you may wish to look more broadly at no just the request and distribution of certificates, but the mechanisms through which the certificate is stored, and there is an overlap with such management with keys as well as certificates. For example APIs may use keys of certificates to help verify authenticity of the request. This also extends to mTLS operations where the client needs certificate to verify the server requests. For example KMIP provides an interface that can support cryptographic object (keys, certificates (public, private, symmetric), secret data, PGP Keys).
There are several impacts that need to be considered:
tracking certificate expiry
Last mile from client deployer to server folder and any refresh nudge required
Tracking certificate expiry
Traditionally certificate expiry management could be handled as a manual process – after all if you have a log of which systems had certificates then if you simply reviewed the list once a month, you could spot expiries with time to spare. Even if the certificate distribution process was automated across many nodes. This just isn’t going to work, and the contingency time incorporated into the certificate life is contracting. Rather than trusting to a tracker spreadsheet being managed we should really focus on actual certificate data. This points to having a means by which application observability has a reporting metric on when a certificate will expire (date or a number of days). The later will prove to be easier as a metrics measure, but the value needs to be in context of when the metric was collected.
Last mile challenge
While automation frameworks like Certbot and step-ca can drive the certificate issuance. These processes get the certificate to the relevant server. But we still need to move the certificate intro the location the application expects the certificate to be, and do we need to nudge the server to reload the certificate? Certbot for example expects to have a script to trigger for this action. This can get a little messy to deploy and maintain, particularly if there are subtle variances in deployments (as a result of manual application deployment in legacy environments), configuration creep etc. One possible way to simplify this is to leverage the capabilities of environment scanners to locate apps and their configs. Then use that to drive the auto creation of that last mile.
Why the change?
The history for the reduction has largely been driven by browser providers particularly Google and Apple, and their security concerns about the trustworthiness of the web’s public key infrastructure (PKI). Historically, certificates could remain valid for several years, creating a prolonged window of exposure if a private key was compromised, a certificate incorrect certificates being wrongly used (organization or domain information became outdated – fore example domain name changes, acquisition of services etc). Certificate revocation mechanisms, particularly CRLs and OCSP, have not proven to be reliable as a means of ensuring browsers quickly stop trusting compromised certificates. Shorter lifetimes reduce this exposure and encourage the automation of certificate management.
The driving of changes has shifted from browser providers unilaterally declaring they won’t trust certificates that are older than a certain age, to a more formalized process governed primarily by the CA/Browser Forum, (an independent body bringing together Certificate Authorities and browser vendors).
Useful resources
A/Browser Forum — TLS Baseline Requirements, version 2.3.1 (4 October 2026), section 6.3.2. Authoritative current hard limits: 398 days before 15 March 2026; 200 days from that date; 100 days from 15 March 2027; 47 days from 15 March 2029. Section 1.1 and the revision history identify 1 July 2012 as the original effective date. https://cabforum.org/working-groups/server/baseline-requirements/requirements/
CA/Browser Forum — FAQ for Baseline Requirements. Historical summary of the 60-month limit from July 2012 and the 39-month general limit from April 2015. This is a historical source, not the current rule set. https://cabforum.org/faq-about-the-baseline-requirements/
CA/Browser Forum — Ballot 193: 825-day Certificate Lifetimes (17 March 2017). Establishes the March 2018 transition to 825 days; also records the preceding 39-month rule and the qualifying 60-month legacy exception through June 2016. The page contains amendment markup; read the replacement wording in context. https://cabforum.org/2017/03/17/ballot-193-825-day-certificate-lifetimes/
Apple — About upcoming limits on trusted certificates. Announces the 398-day maximum for public TLS server certificates issued on or after 1 September 2020 and explains its scope. This change originated in browser/platform trust policy. https://support.apple.com/en-us/102028
CA/Browser Forum — Ballot SC081v3: Introduce Schedule of Reducing Validity and Data Reuse Periods (11 April 2025). Records the successful vote for the 2026–2029 reductions; source 1 confirms the resulting current requirements. The April milestone is the vote result, not the end of the subsequent intellectual-property review period. https://cabforum.org/2025/04/11/ballot-sc081v3-introduce-schedule-of-reducing-validity-and-data-reuse-periods/
RFC Editor — RFC 8555: Automatic Certificate Management Environment (ACME), March 2019. Standards-track specification, published as a Proposed Standard. https://www.rfc-editor.org/info/rfc8555/
CMP over HTTP — RFC 9811: Defines HTTP transport for CMP messages.
EST — RFC 7030: Enrollment over Secure Transport; supports certificate enrolment and re-enrolment over HTTPS.
SCEP — RFC 8894: Simple Certificate Enrolment Protocol; commonly used for network devices.
CMC — RFC 5272: Certificate Management over CMS; supports certificate requests and management messages. Updated to — RFC 10002: Updated specification superseding RFC 5272.
KMIP 2.1 — OASIS KMIP 2.1 Specification: Key Management Interoperability Protocol; manages cryptographic keys, certificates and other cryptographic objects.
PKCS#11 3.1 — OASIS PKCS#11 3.1 Specification: Cryptographic Token Interface; standard API for accessing cryptographic hardware and software tokens.
SCIM 2.0 — RFC 7644: System for Cross-domain Identity Management; supports identity and account provisioning rather than certificate management.
SPIFFE — SPIFFE Specifications: Secure Production Identity Framework for Everyone; standardizes workload identity across heterogeneous systems.
X.509-SVID — X.509-SVID Specification: Defines X.509 certificates used for workload identity and authentication.
X.509 PKIX — RFC 5280: Defines the Internet X.509 public key certificate and Certificate Revocation List (CRL) profile.
CA/Browser Forum Baseline Requirements — Current Baseline Requirements: Industry requirements governing publicly trusted TLS certificate issuance, domain validation, security practices and maximum certificate validity periods.
With the recent upheaval from the newly discovered PHP vulnerability (often referred to as PHP2Shell), and updates to OpenTelemetry declarations, it struck me that it’s worth highlighting an assumption we all tend to make with patches.
We tend to think patches introduce fixes or defences that mean functional behavior is immutable. It is an understandable reading based on definitions such as Semantic Versioning (semver):
PATCH version when you make backward compatible bug fixes
However, languages and frameworks point towards a different model, where defined API behaviour will be respected.
The bottom line is if you’re exploiting undocumented behaviors, it makes it all the more necessary to test and ideally in an automated manner changes not only in the applications but also for the stack.
If you are taking advantage of undocumented behavior, then it is worth adding an abstraction layer to allow mitigation changes to be added.
The following identifies the statements at a language level relating to what impact a patch can have:
Language / runtime
Behavior changes in patches
Breaking API changes in patches
Policy, limitations and supporting documentation
Go
Yes
Exceptional
Explicit security, unspecified-behavior and specification-correction exceptions. Go compatibility promise
PHP
Yes, for corrections
Generally no
Security and bug fixes permitted; public userland API must remain backward compatible. Internal ABI/API has narrowly defined exceptions. PHP release policy
Python (CPython)
Yes, restricted
Exceptional
Reasonable bug fixes may affect behavior; stronger incompatibilities require exceptional justification. PEP 387
Java (OpenJDK / Oracle JDK)
Yes
Generally no
Security corrections can alter runtime behavior; source, binary and behavioral compatibility are evaluated separately. OpenJDK compatibility
C# / .NET runtime
Exceptional
Exceptional
Breaking changes generally prohibited during servicing, except for security vulnerabilities or other critical issues. .NET release policy
F# / .NET runtime
Exceptional
Exceptional
Shares .NET runtime servicing policies; compiler and language tooling have their own compatibility considerations. .NET compatibility rules
VB.NET / .NET runtime
Exceptional
Exceptional
Same underlying .NET servicing guarantees. .NET servicing
TypeScript
Yes, restricted
Not normally
Patch releases may contain high-priority regression, performance-regression and safe language-service corrections. Ordinary breaking changes are targeted at larger releases. TypeScript release process
JavaScript (ECMAScript)
Not applicable at language-specification level
Not applicable
ECMAScript is a specification, not a separately patched runtime. Behavior depends on implementations such as V8, SpiderMonkey, JavaScriptCore and Node.js. ECMAScript specification
Node.js
Yes, for corrections
Exceptional
Patch releases accept fixes; semver-major changes are excluded under normal procedures. LTS security exceptions can affect native API/ABI compatibility when unavoidable. Node.js release procedures
The following table, takes the same approach looking at how operating systems view changes for patches:
Operating system
Behavior changes in maintenance patches
Breaking API / ABI changes
Policy, limitations and supporting documentation
Red Hat Enterprise Linux (RHEL)
Yes
Generally avoided
Backports security and bug fixes into supported versions. Red Hat explicitly tests for unwanted side effects, so this is not general permission to break compatibility. RHEL security backporting
SUSE Linux Enterprise Server (SLES)
Yes
Generally avoided
Maintenance includes security corrections and defect fixes; individual components have different lifecycle rules. Service packs allow broader changes. SUSE support policy and SLES release notes
Oracle Linux
Yes
No general permission established
Oracle distributes security, bug-fix and enhancement errata as package updates. Security hardening can alter functionality independently of major OS releases. Oracle Linux errata policy
Ubuntu LTS
Yes, cautiously
Generally avoided
Backported security patches prioritize compatibility. Exceptional changes and certain feature updates can be accepted under the Stable Release Updates process. Ubuntu security updates
Debian Stable
Yes, restricted
Generally avoided
Important bug and security fixes are acceptable; updates are deliberately minimal and require review. Debian Stable update rules
Microsoft Windows 11 / Windows Server
Yes
No general permission established
Cumulative security, quality and out-of-band updates may change functionality. Windows 11 may also deliver feature enhancements through monthly servicing. Windows update release policy
Apple macOS
Possible
No general permission established
Security and maintenance releases can affect operating behavior, but there is no general published patch-version exception equivalent to Go’s. Apple security releases
Often when building solutions we don’t see low level frameworks and how they work, so we may not know about any undocumented feature exploitation.
The challenge it can bring
This points to increased testing, which ideally is automated. The reaction is initially is so what. But, when vulnerabilities like PHP come up which had openly triggered systems being disconnected from the net.
So extending testing (even if automated) is going to experience resistance from the commercial parts of an organization who are unlikely to understand the nuances, but will react to headlining risks.
How do we move forward?
There are some strategies we can adopt that can help us. The industry used to talk about security in depth and, more recently, system resilience. Regardless of terminology, we want to introduce control layers that reduce the chance of malicious intent. Often referred to as compensating controls.
For example, if the vulnerability is overloading the runtime by sending an oversized payload, a firewall or proxy layer can have rules that prevent payloads from being too big from hitting the backend.
If the networking allows it, then segmenting the network reduces the risk of a breach affecting other environments.
This doesn’t mean if we can patch, that we shouldn’t. What it does mean is we can be considered and not knee-jerk panic and unwittingly introduce new problems.
Conclusion
Adding additional security and proxy layers and segmenting system environments may seem like overkill, particularly when introducing new systems. But these steps create the means to be far more resilient.
Last week saw the Open Source Observability Day (OSOD) during which I presented on the subject of the Open Agent Management Protocol, covering the underlying protocol that forms the foundation of a wider capability we have been building along with a demo of what is available.
If you want to see the presentation, and hear the full story not only of the core protocol but how it can help with the ideas around ChatOps and AIOps head over to the OSOD website (and previous years can be seen on YouTube with playlists for each year e.g. OSOD 2025). Of course if you have been following my blog posts you’ll know this.
The demo is recorded against a version prior to the 0.6 release.
Running the demo yourself
If you want to try this out for yourself, you can do so. You’ll need to:
There are several things that separate the turn-key/commercial observability solutions from the pure open source options. The most visible of these are:
Fleet management of you agents, particularly when working outside of a Kubernetes ecosystem
Deployed services and applications with default monitoring configuration
Prebuilt dashboards
While the issue of fleet management is a subject I’ve covered at length with OpAMP. We’ve not looked so closely at the discovery and automation. While the OpAMP server (and standalone option) provides schema driven editor, the key separation is to drive the configuration based on finding what solutions are deployed.
This process can look very sophisticated, but there are a number of open source tools that can help address it pretty easily. By bringing therse tools together we can achieve the same effect of detect and configure agents. At this stage we’re not looking at the backend of creating out of the box dashboards, but the potential to evolve the approach is there.
Detecting and Generating Configuration
The process we need has the following steps:
find the deployed solution(s)
Understand how they are deployed
Generate a configuration based on the detection
Push the configuration out to agents
Detect and capture config
One of the more active solutions that provides a means to detect deployments, and find configurations in this space is OSQuery, which is used by some serious players (Airbnb, Dropbox, Netflix, Palantir, Etsy, and Uber are just a few). OSQuery is particularly appealing solution because of its ease of use. All the information OSQuery can make available is accessible through the use of SQL including all the power SQL provides to mix data together.
While SQL is powerful, we do want to return the results in an easily consumable manner, so the CLI tool allows us to ask for the result to be returned in JSON. This makes the result easy to work with and we can use it with technologies such as JSONPath, particularly if we can impose a defined schema on the output, something that can be done as we know the queries being run, and can use constructs such as select … as …
As we can query the JSON output to retrieve the relevant parts of the output, for example the result of the queries to look for an Oracle Database or a RedHat/IBM WildFly application server. We can then combine that data with a template, such as the templating capabilities of Jinja2. The template defines the configuration that we would want to use, for example we want to tail log files, we want to establish a Prometheus metrics pull. Then the values are pulled from the JSON to create an instance of the file.
Templates make the result reusable
By using templates, known queries and their result structures we can generate reusable configurations on a product by product basis. The last step is stitching it together. To be reusable each template is discrete for an application or standard stack. So we up with multiple configuration files that need to be combined. This could be addressed by simply merging all the files together, but a lot of the observability tools such as Fluent Bit and Fluentd provide the ability to include files. Obviously you still need to work out what to include to combine, but this pretty straight forward.
There are limits
So this brings together all the sources, for destination side for the turn key solutions is known as the backend is the core product. In the open source solution you’re probably going to run multiple tools, so you need to have a more advanced routing. You can create a standard backend routing and include it.
Convenience as a weakness?
While having turn-key solutions, makes setup so much easier, could it also be a weakness? As we can see with our automation, we’ve not got tailoring to filter data in the pipeline, or park it out of the way. Which ratchets up the costs, because of the retention costs, and greater computational effort to trawl the data. Nor can we derive new signals through correlation inflight. But then our approach with templating creates the same challenge, BUT this approach doesn’t preclude you from incorporating into the solution such smarts.
Backend Bootstrapping
Rapid configuration of the backend is going to be a bit harder because the chances are you’re wanting to mix and match the backend tools (one of the strengths of not going down a turnkey adoption). We’ll explore the possibilities of making this step easier in another post.
We’ve made the latest version of our implementation of the OpAMP specification available. It has taken longer to ready than the previous versions, but there is a lot been included, both in the core functionality, but also capabilities supporting the use and setup. Here are the headlines…
Automated regression from clean to deployed and running a series of end-to-end tests as well as producing a guaranteed fresh set of artefacts has been implemented. This can be run against AWS (currently in use) or Azure (needs refining). These are triggered on changes to the main branch.
GitHub pages with links all the documentation are established now.
The Python wheel release artefacts are no incorporated into the release assets.
The client/consumer side has been refactored so it is easy to build your own observability agent controls and independently deploy them (not supported by the config editor).
The CLI has been enhanced so it can help quickly spin up more advanced configurations – helpful for demos and real deployments.
The Dev CLI has been improved.
The server side now has a basic client side (Supervisor/Observer) configuration editor UI. Which can be deployed as a plugin.
Improvements around the use of Podman and Docker for the containerization.
What next?
We’ve added to the documentation pages for the roadmap, initially we’re working to fill out the regression test sets at the moment. Other possibilities:
Expand the client types
Extend the client types to exploit more features.
Perhaps the most interesting idea, we’re thinking about is can we exploit tools like Netdata to discover what solutions are deployed and generate a requirements/configuration definition which can be used to generate a suitable agent configuration file.
You must be logged in to post a comment.