There has long been a disconnect between monitoring infrastructure, applications, and business outcomes.
Infrastructure teams use tools to monitor CPU, Memory, and Network consumption, which all provide valuable information about the capacity and performance of the system. Application teams use a different set of tools to look at performance (e.g., transactions, failures, code deployments and vulnerabilities) allowing the development teams to quickly address failures or security risks inside the application. Business teams look at metrics around the end user experience, traffic volumes, adoption, and abandon rates to determine marketing strategies, user behavior, etc.
Having all these tools and departments look at different areas without the benefit of correlation leads to confusion. cloudEQ’s Application Command Center (ACC) combines the metrics of infrastructure and application IT teams into a single view and allows that to feed business metrics.
Services used
React JS
Partners used
New Relic
Overview
of ACC
of ACC
The Application Command Center (ACC) is an Observability tool built by cloudEQ to provide a single source of truth for complex enterprise applications. It’s made using the Observability as Code (OaC) approach, which is easy to maintain and expand by the SRE team.
It provides a Single Pane of Glass for monitoring the infrastructure health through:
- Synthetic ping monitoring for microservices
- API endpoints
- Synthetic monitoring of test cases
- Error Inbox for all application errors
- Monitoring of Service Level Indicators (SLI)
- Service Level Objectives (SLO) for microservices
- APIs
The ACC is designed to provide early warning indicators and reduce Mean Time to Recovery (MTTR). A call-to-action connects various data points to a workload navigating directly into the problem area, reducing the time it takes to debug the application.
Workloads are built using NRQL, which pulls information from various sources like APM, logs, events, alerts, infrastructure agents, synthetic monitoring, and CB Pattern visibility, making it easy for the SRE team to act before any significant incident occurs.
Why ?
Why We Need ACC?
As applications move to the cloud and adopt microservices and distributed architectures, it becomes increasingly important to have a robust observability strategy. The complexity of these applications makes it challenging to understand the health and performance of the system as a whole.
To address these challenges, it’s crucial to have a centralized logging and monitoring platform that can aggregate data from different sources and provide a unified view of the application’s health and performance. This can include log data from microservices, metrics from serverless functions and Kubernetes clusters, and data from third-party applications that the system interacts with.
Additionally, it’s essential to use tools that provide end-to-end visibility across the application and its dependencies, such as distributed tracing, metrics, and logging. Quick identification and troubleshooting are imperative to the application’s overall performance and reliability.
A well-defined governance must be in place to ensure that all data is collected, processed, and stored consistently and securely, enabling the right people to always have access to the correct data.
Design
ACC is designed to present the most valuable information in a self-presentable user experience. The dashboard shows all the high-value KPIs essential to understand the health and performance of your application and its underlying infrastructure.
Key Features
Single Pane of Glass for your application’s observability: a unified view of your application’s health and performance to individual micro-services or API Levels, including infrastructure metrics, logs, Synthetic scripts, and alerts from different sources, in one place.
Infrastructure health monitoring: audit the performance of your underlying infrastructure, such as servers, Kubernetes clusters, or serverless functions – indicating infrastructure performance.
Synthetic Ping monitor for microservices or API endpoints: proactively check availability and responsiveness to ensure that your application is accessible to users and other systems.
Synthetic monitoring of test cases for your microservices or APIs: track the status of use cases implemented for a particular micro-service or API
Error Inbox: see how many errors in total your micro-service or API endpoints currently have. This provides pinpointed information about the operational behavior of your microservice or APIs level.
SLI and SLO monitoring for your microservices or APIs: track your application’s service level indicators (SLIs) and service level objectives (SLOs) for each micro-service level / API level for error rate/quality, availability, and latency or response time.
CB patterns visibility for your micro-services: Circuit Breaker (CB) patterns are a common way to improve the resilience of microservices-based applications by preventing cascading failures. CB patterns can also provide valuable visibility into individual microservices’ health and performance and their interactions. To achieve visibility into CB patterns, you can use tools like Istio, gobreaker & open services mesh (OSM) which provide built-in CB functionality and metrics. ACC provides visibility to circuit breakers, which helps you proactively understand your microservice’s operational behavior and make it more resilient over time.
Workloads Connected: composite views are built to provide a view for simultaneous monitoring (Infra, APM, synthetic, alerts, logs, and errors) and can be customized depending on your requirements.
Observability as Code Dashboard: ACC is a code driven dashboard, which makes it easy to expand it to add new features to the ACC and onboard and apply it to other applications as well; it is powered by GitHub actions pipeline to build, test and deploy this, which make it easy to maintain and deploy.
Navigation: access different areas of the application, such as specific microservices or API endpoints, and view the relevant data for those areas.
Microservices / APIs Performance: track the performance of microservice’s or API’s endpoint level to give you an idea of how application APIs or microservices perform with actual requests.
These features combined provide a comprehensive view of your application’s health and performance, allowing you to quickly identify and resolve issues and proactively improve the availability, resilience, reliability, and quality of your application, thereby building a solid digital immune system for your enterprise.
The Application Command Center (ACC) is designed to make it easy for the SRE team to aggregate data from various sources, such as APM, logs, events, alerts, infrastructure agents, and synthetic monitoring, into a single place using NRQL & workloads.
The ACC's data-driven navigation provides a comprehensive view of the application's health and performance, allowing you to drill down into specific areas quickly. This significantly reduces the time it takes to debug issues and identify the root cause before they become major incidents.
Additionally, the ability to correlate data from different sources in real-time, using the NRQL, provides valuable insights for identifying and troubleshooting issues - proactively improving the overall quality and reliability of the application.
Overall, the ACC is a powerful tool that significantly improves observability and management of complex enterprise applications, allowing SRE teams to be proactive in identifying and resolving issues, resulting in improved overall resilience.
