LogicMonitor is expanding its Enterprise Data Foundation with support for OpenTelemetry metric ingestion and integrated infrastructure cost tracking, giving organisations a broader way to understand both the technical and financial behaviour of increasingly complex IT environments. The additions are aimed at improving the quality and consistency of telemetry feeding modern observability platforms and AI-powered IT operations.
The company says its platform already processes more than two trillion metrics every day across its enterprise customer base. With OpenTelemetry support and cost information now becoming part of that foundation, LogicMonitor wants organisations to move beyond fragmented monitoring and build a more complete operational picture before relying heavily on AI-generated analysis or automated remediation.
Reliable AI Depends On Reliable Telemetry
LogicMonitor CTO Prabhu Nakkeeran argues that the usefulness of AI for IT operations ultimately depends on the quality of the telemetry underneath it. An AI system can only make reliable conclusions when it has complete, governed and accessible information about what is happening across the environment.
This becomes particularly important as organisations increasingly use AI to investigate incidents automatically. A sophisticated model may appear to make a poor decision when the real problem is that it never received the information required to understand what was actually happening.
According to Nakkeeran, organisations evaluating AI-powered IT operations should first ask three basic questions about their data foundation: Is it complete? Is it governed? Is it consumable? If the answer to all three is yes, the AI and automation layers built above that data become much more trustworthy.
Incomplete Monitoring Can Lead AI To The Wrong Conclusion
One of the biggest problems in enterprise observability is incomplete visibility. An automated investigation may correctly analyse all the telemetry available to it and still arrive at the wrong answer because an important system was never being monitored in the first place.
LogicMonitor provides an example where an automated diagnostic system blamed application latency on database performance. The database appeared to be the likely cause based on the available information, but the actual problem originated from network hardware that had never been discovered by the monitoring platform.
In that case, a firewall cluster did not support the standard SNMP monitoring approach being used. Because telemetry from the firewall was missing entirely, the AI had no evidence showing that network infrastructure was causing the slowdown.
Blind Spots Can Appear Across Hybrid Environments
Modern enterprise infrastructure creates plenty of opportunities for these monitoring gaps. Branch-office SD-WAN appliances, storage systems and specialised network hardware may not always integrate cleanly with conventional monitoring tools.
Cloud environments introduce another problem. Credentials used by monitoring systems can expire silently, cutting off telemetry without immediately making it obvious that visibility has disappeared.
The result can be an observability platform that appears healthy while important parts of the environment have effectively gone dark. If AI systems operate on top of those incomplete datasets, they can produce confident but misleading conclusions.
Telemetry Governance Is Just As Important As Collection
Collecting enormous amounts of data also creates its own problems. Organisations can end up accumulating metrics indefinitely without clearly defined retention policies, ownership structures or access controls.
That creates governance and potentially compliance risks, particularly when different business units operate under different regulatory requirements. Organisations need ways to partition data appropriately and prevent teams from accessing operational information they should not see.
Disjointed monitoring tools can make governance more difficult because each platform may identify the same server, application or device differently. Without common identities across datasets, correlating events becomes harder and AI systems have to work around unnecessary inconsistencies.
OpenTelemetry Helps Standardise Metric Collection
LogicMonitor is addressing some of these visibility gaps by allowing its Enterprise Data Foundation to ingest push-based metrics through OpenTelemetry.
Organisations can send telemetry using upstream open-source OpenTelemetry collectors or LogicMonitor's own collectors. This provides another collection method alongside traditional polling-based monitoring.
The push model is particularly useful in environments where older mechanisms such as SNMP are difficult or impossible to use. Devices and applications can stream metrics outward instead of requiring the monitoring platform to continuously poll them.
Push-Based Collection Can Reach Difficult Environments
Traditional network monitoring frequently depends on the monitoring system being able to reach the device directly. That approach can become complicated when infrastructure sits inside segmented networks, isolated locations or highly controlled environments.
OpenTelemetry changes that model by allowing collectors positioned closer to the workload to send information outward. This can provide visibility into environments that would otherwise require complicated firewall rules or proprietary monitoring agents.
For hybrid infrastructure spanning on-premises systems, cloud services and remote locations, this flexibility can make telemetry collection significantly easier to standardise.
Application Tracing Remains Separate
The new OpenTelemetry metric ingestion capability does not mean every type of observability data is being handled through the same pipeline yet. Application performance traces continue to be managed through LogicMonitor APM.
Logs are also not part of the new native OpenTelemetry ingestion path at this stage. LogicMonitor says it plans to introduce native support for ingesting OpenTelemetry logs later.
This means the platform is gradually broadening its OpenTelemetry capabilities rather than replacing its existing observability architecture all at once.
Legacy Windows Environments Are Also Being Covered
OpenTelemetry is not only useful for modern cloud-native applications. LogicMonitor is also using the technology to improve visibility into older Windows environments.
Through the OpenTelemetry Windows collector, the platform can capture application-level request metrics from Microsoft Internet Information Services, better known as IIS.
This includes information such as HTTP response codes, failing endpoints and request durations. These metrics provide additional insight into web applications running on Windows infrastructure that may previously have been difficult to instrument using modern observability approaches.
Preconfigured Queries Could Make IIS Monitoring Easier
LogicMonitor is preparing preconfigured query packs designed around this IIS telemetry. The idea is to reduce the amount of manual work required before administrators can begin analysing common web-server problems.
Instead of building every query from scratch, teams could use prepared views that highlight failed requests, slow responses or unusual application behaviour.
This is particularly useful for organisations that still operate significant amounts of legacy Windows infrastructure while simultaneously adopting newer observability standards.
Modernisation does not always mean replacing older systems immediately. Sometimes it means making those existing environments easier to understand using newer telemetry technologies.
Cost Is Becoming Another Form Of Telemetry
One of the more interesting additions is the integration of infrastructure cost information directly alongside traditional technical metrics.
Nakkeeran argues that cost itself should be treated as telemetry. In many organisations, performance metrics live inside monitoring platforms while cloud expenditure and infrastructure costs are managed by finance or FinOps teams using completely separate tools.
That separation means operational decisions may be made without considering the financial implications. A technically effective solution might resolve an incident but significantly increase infrastructure spending.
By combining both forms of information, LogicMonitor wants technical and commercial context to exist within the same decision-making environment.
Edwin AI Can Consider Technical And Financial Context Together
LogicMonitor's Edwin AI platform can use cost information alongside operational telemetry when investigating incidents. Instead of asking only which action is technically possible, the system can also consider the commercial impact of potential remediation options.
Imagine an application experiencing heavy demand. One solution might be to dramatically increase cloud capacity, which could resolve the performance problem quickly but also create substantial additional expenditure.
An AI system with cost context could potentially evaluate whether another remediation approach offers sufficient performance improvement at a lower financial cost.
This brings FinOps considerations much closer to day-to-day IT operations.
Infrastructure Cost Can Influence Operational Decisions
The ability to correlate cost and performance could become increasingly important as enterprise infrastructure becomes more dynamic. Cloud services make it easy to add computing capacity rapidly, but that convenience can also cause spending to increase just as quickly.
Traditional monitoring systems might celebrate additional capacity because performance improves. Finance teams may see the same change very differently when the monthly cloud bill arrives.
Putting both perspectives into the same operational platform can help teams understand the trade-offs immediately rather than discovering them later.
This is especially relevant for AI workloads, which can consume expensive GPU and cloud resources very quickly.
Edwin AI Can Also Execute Governed Actions
LogicMonitor is positioning Edwin AI as more than an investigation tool. Once technical and financial context has been evaluated, the system can execute approved operational actions directly.
The important word here is governed. Automated actions need to operate within policies defined by the organisation rather than allowing an AI agent to make unrestricted infrastructure changes.
This could enable incident investigations to progress from detection through analysis and eventually into remediation without requiring humans to manually perform every intermediate step.
For repetitive operational problems, that could significantly reduce mean time to resolution.
AI Operations Are Moving From Reports Towards Decisions
Traditional monitoring tools are excellent at showing administrators what happened. Dashboards, graphs and alerts provide enormous amounts of information, but engineers still need to interpret that information and decide what to do next.
AI-powered operations are increasingly trying to move further along that chain.
Instead of producing another report, the system attempts to determine what the evidence means, which remediation options are available and which action best fits organisational policies.
As Nakkeeran puts it, data designed for action allows an investigation to end in a decision rather than simply producing another report for someone to analyse.
OpenTelemetry Reduces Dependence On Proprietary Instrumentation
Another advantage of OpenTelemetry is its open nature. Organisations can collect metrics using a widely adopted standard rather than depending entirely on instrumentation designed for one monitoring vendor.
This makes telemetry more portable and reduces the amount of proprietary code required inside applications.
It also allows development teams to instrument software once and potentially send that information into several compatible observability platforms.
For organisations trying to avoid excessive vendor lock-in, that flexibility can become an important architectural consideration.
A Complete Data Foundation Matters More As AI Adoption Grows
The broader message behind LogicMonitor's update is that organisations should not rush towards AI-powered operations without first examining the data foundation supporting those systems.
AI can correlate enormous volumes of telemetry faster than a human operator, but more processing power does not compensate for missing information. If one critical network device is invisible, the model may confidently diagnose the wrong component.
The same problem applies to governance. If several monitoring systems describe the same resource differently, AI has to spend additional effort reconciling identities before it can reason accurately across the environment.
Building a reliable telemetry foundation may therefore be one of the most important steps organisations can take before introducing increasingly autonomous operational systems.
Observability Is Becoming Broader Than Performance Monitoring
Enterprise observability once focused primarily on whether servers were available and applications were responding quickly. The scope has expanded considerably.
Modern platforms increasingly need to understand infrastructure, applications, network behaviour, cloud services, security context and now financial cost.
OpenTelemetry provides a common mechanism for collecting much of that operational information, while cost integration adds another dimension that traditionally existed outside observability platforms.
The result is a much broader interpretation of what operational telemetry actually means.
Final Thoughts
LogicMonitor's expansion of its Enterprise Data Foundation shows how observability is evolving as AI becomes increasingly involved in IT operations. OpenTelemetry metric ingestion gives organisations another way to close monitoring gaps across hybrid and legacy environments, while integrated infrastructure cost data allows technical decisions to be evaluated alongside their financial consequences.
The most important point may be LogicMonitor's argument that trustworthy AI begins with trustworthy telemetry. An AI system reasoning across incomplete monitoring data can reach the wrong conclusion even when the model itself is functioning exactly as designed.
By combining OpenTelemetry, infrastructure visibility, cost information and Edwin AI, LogicMonitor is attempting to create a data foundation where automated investigations can progress towards actual operational decisions rather than simply producing more dashboards and reports.
As organisations move towards increasingly autonomous IT operations, that foundation could become more important than the AI model sitting on top of it.
Comments 0