• Topics

What Is Observability? Concepts, Use Cases, and Technologies

What is Observability?

Observability is a strategy for managing IT services and software. Its main focus is ensuring the most relevant and important issues are captured and addressed in operational processes. Observability also describes software processes that help collect and process critical information from computing systems.

In control theory, observability is defined as a way to estimate the internal state of a system from the relationship between inputs and outputs. This is known as a top-down evaluation. The main goal of observability is not to derive internal state from observations, but to collect the best possible observations that can help determine the internal state.

Observability should not be confused with monitoring. Monitoring is an action or process that collects information from a computing system. Observability is a property of a system, which ensures the internal state of the system can easily be observed. Monitoring systems are an important part of most observability strategies.

Why is Observability Important?

Software development is transitioning to a microservices architecture, with software built primarily of open source components, and running in cloud native environments. A modern software project is composed of dozens or hundreds of independent microservices, each with one or more service instances, creating potentially thousands of operational units. 

In addition to this complexity, distributed teams are developing and deploying software faster than ever. The DevOps work process and the continuous integration / continuous delivery (CI/CD) tool chain make the entire software delivery process faster than ever before. This means it is harder to identify problems in new software releases.

A microservices environment is drastically different from traditional monolithic applications. Monolithic applications were built as one unit, which was pre-configured and running for long periods of time on the same server. This meant that when problems arose, it was relatively easy to understand why and alert operators. These systems typically failed in a predictable way.

This is no longer the case, and today monitoring tools need to uncover what is happening in a dynamic distributed system, and connect it to application performance. The process involves gathering monitoring data from multiple service instances, aggregating and analyzing it, commonly using time series analysis. To achieve observability, microservices need to have the ability to collect, store, and share the most relevant metrics about their daily operations.

Observability vs. Monitoring: What is the Difference?

Observability and observability are different, yet related concepts. 

Monitoring is an action you take to collect information from a running system. It is the act of observing system performance over time. Monitoring tools collect and analyze system data and turn it into actionable insights. Data aggregation, correlation, and machine learning techniques can provide additional insights about a system’s operational state.

For example, application performance monitoring (APM) tools can identify if a system is up and running, or if there are any application performance issues, and notify operators. 

Observability, like functional and testability, is a property of this system. It measures the degree to which a system’s internal state can be inferred from its outputs. Observability uses the data and insights generated by monitoring to provide a comprehensive view of system health and performance. 

System observability depends how monitoring metrics interpret performance metrics. When building a system for observability, you will need to know in advance what metrics are important and how they can be measured. This will make it possible to collect critical information that shows how the system behaves over time.

4 Fundamentals of Observability

With the wide adoption of microservices platforms, commercial vendors and open source contributors have created observability platforms. These platforms integrate with existing instrumentation built into applications and infrastructure components, and make it possible to create better instrumentation that collects critical telemetry data. 

Let’s review the main functional areas of an observability platform—logs, metrics, traces, and dependencies.


Logs are collections of events, typically recorded in text or human-readable format. They might be created by infrastructure elements, such as servers or network equipment, by platforms such as operating systems and middleware, and by software applications. Traditionally, log information was historical, used to establish a context for operational management. Today, it is becoming common for log data to be collected, processed and analyzed in real time.


Metrics are real-time operational data, typically accessed through APIs. Examples of metrics are % of CPU utilization, available storage space, bandwidth used, or throughput of transactions.

Metrics can be pulled or polled by monitoring systems. Alternatively, an observed system can itself generate telemetry data and push it to an observability system, or directly to operators as notifications. Most fault management processes are driven by metrics, because they are event-driven.


A trace is a record of an information path or workflow designed to follow a unit of work (such as a transaction) through a set of processes determined by application logic. Tracing is an indirect way to evaluate application logic in an application, which takes into account steering of traffic through components like proxies, load balancers, or service meshes. 

Some trace data can be collected directly from operational processes, but in most microservices environments, you will need to use a dedicated tracing tool. Incorporating tracing into your software development process can improve visibility, making it easier to debug system failure, functional and performance issues affecting multiple components.


Dependencies, also known as dependency graphs, show how each application component depends on other components, applications, and IT resources.

After collecting this telemetry, an observability platform can correlate it in real time, providing important context to DevOps teams and site reliability engineers (SRE). Dependencies can be used to troubleshoot application performance and gather actionable insights.

Observability Use Cases

Let’s take a look at a few real life use cases in which observability is helping organizations manage production systems, despite the increasingly complex business and IT environment.

Microservices Observability

To achieve observability for microservices, the data needed to identify problems and detect errors needs to be accessible to development teams. For example, an observable system can help a developer understand why a particular service call failed, or identify the cause of a bottleneck in an application’s workflow.

In a microservices environment, the ability to monitor systems for effective debugging and diagnostics is critical. Services can span multiple machines and typically run independently, meaning that tracking down the cause of a failure is a difficult and time-consuming task.

Learn more in the detailed guides to:

Cloud Observability

As cloud architecture evolves, it creates complexity, scale, and security issues. Cloud observability addresses these challenges. Cloud observability provides data insights to keep your cloud application or service running and provides visibility over the entire cloud ecosystem.

Investing in observability will make it easier to identify and solve problems with cloud applications. Observability is not complete without a system that can intelligently monitor and analyze performance in a hybrid cloud environment. These systems are typically big data processing engines.

Learn more in the detailed guides to: 

Kubernetes Observability

Kubernetes automates the deployment, management, and scaling of containers, making it possible to operate hundreds or thousands of containers and manage reliable and resilient services.

Kubernetes is based on a declarative model. Once you define the desired system state, Kubernetes ensures that your cluster meets these requirements and automatically adds, removes, or replaces containers, organized in units called pods.

Because Kubernetes has a self-healing design, it can give the impression that both observability and monitoring are built in. However, this is not true. Some operations, such as replacing failed cluster nodes and scaling services, are automatic, but you still need to build observability into a cluster to keep tabs on the health and performance of your deployments. 

Log data from Kubernetes components and applications deployed in a Kubernetes cluster plays a key role in creating an observable system. By monitoring logs in real time, you can better understand how your system is performing and proactively troubleshoot problems before they cause damage.

Learn more in the detailed guide to Kubernetes monitoring

Serverless Observability

Serverless is a cloud-native development model that allows developers to build and run applications without managing servers. Serverless computing is typically billed according to the actual time a piece of code, known as a serverless function, actually ran.

Implementing observability in serverless applications can be challenging. This is mainly due to the nature of event-driven serverless functions. Each function is isolated, works independently, and is temporary (often running for only a few minutes). Customization is required to achieve observability to this environment.

In a serverless application, in order to debug issues, you need to be able to visualize the entire serverless transaction lifecycle. Only automated tools can provide distributed tracing across multiple serverless resources.

Learn more in the detailed guide to serverless monitoring

IoT Observability

As IoT systems grow, they generate vast amounts of data that are difficult to collect and analyze. Yet this data contains valuable information about the health, performance, and activity of devices and the applications that support them.

IoT observability solutions focus on collecting critical machine data, and providing meaningful views of the data that can help improve performance, avoid downtime and monitor for security breaches. This makes it possible to identify critical issues and address them in affected devices.

API Observability

As software development evolves, more and more application functionality is exposed as application programming interfaces (APIs), or consumed via internal or external APIs. This move to API-based code reduces the engineer’s ability to see an application’s behavior as a whole, complicates everything, and makes it difficult to understand how the application’s components interact.

APIs break the traditional software development and maintenance lifecycle. They create complex interactions and can fail in new ways. Observability can help manage the migration to APIs and ensure applications remain performant and resilient.

API observability can solve many issues related to API consistency, stability, and the ability to quickly iterate on new features. Full stack observability design gives you everything you need to discover problems and catch major changes before they do any harm.

Learn more in the detailed guide to API security

5 Challenges of Observability

Cloud and microservices environments generate far more telemetry than traditional systems. They also generate more diverse telemetry data, which teams need to learn to interpret. The speed at which all this data arrives makes it difficult to keep up with the flow of information, analyze it effectively, and use it to troubleshoot infrastructure or application issues.

Common observability challenges include:

  1. Data silos—organizations manage disparate data sources, and multiple, isolated monitoring tools. This makes it difficult to understand the interactions between systems and components in the same environment, and between different environments such as private cloud, public cloud, and the IoT.
  2. The three Vs (volume, speed, and variety)—huge volumes of raw data are generated by the myriad components of platforms such as AWS, Azure, Google Cloud, and Kubernetes. Specialized tooling is required to collect, process, and analyze this data to derive operational insights.
  3. Manual instrumentation and configuration—it is often required to manually instrument and modify the code of each new type of component or agent. This means much of the time of operations teams is spent on deployment of agents and configuration, rather than extracting value from observability data.
  4. No effective staging environments—complex cloud and microservices systems cannot be fully simulated in a “sandbox” or staging environment before code is pushed to production.
  5. Complex troubleshooting—applications, operations, infrastructure, development, and digital experience teams all try to troubleshoot  and determine the root cause of problems based on a patchwork of telemetry data which does not always contain the right metrics.

Observability Examples

Let’s review some common errors found in cloud native environments and how to make them easier to detect and solve using the principles of observability.

5xx Server Errors

5xx errors are returned as part of the Hypertext Transfer Protocol (HTTP). It is the basis of most communications on the Internet and in private networks. 5xx error means “error number starting with 5”, such as 500 or 503. 5xx errors are server errors. In other words, the server has encountered a problem and cannot process the client’s request.

In most cases, the client cannot resolve 5xx errors. This error usually indicates a software, hardware, or configuration problem with the server that needs to be repaired. When this error is encountered as part of communication between microservices or containers, it can cause interruption of service or performance issues. 

How can observability principles help resolve this error?

An observable system provides meaningful logs explaining the context and events that led to a 5xx error. This allows monitoring and quick resolution by operations teams.

Learn more in the detailed guide to 5xx Server Errors

Exit Codes

Exit codes are used by container engines, when a container terminates, to report why it was terminated. If you are a Kubernetes user, container failures are one of the most common causes of pod exceptions

The most common exit codes used by containers are:

  • Exit Code 0. Used by developers to indicate that the container was automatically stopped
  • Exit Code 1. Container was stopped due to application error or incorrect reference in the image specification
  • Exit Code 125. The docker run command did not execute successfully
  • Exit Code 137. Container was immediately terminated by the operating system via SIGKILL signal
  • Exit Code 139. Container attempted to access memory that was not assigned to it and was terminated
  • Exit Code 255. Container exited, returning an exit code outside the acceptable range, meaning the cause of the error is not known

How can observability principles help resolve this error?

Container failures can be complex to debug because they can involve interaction between an application running in the container, the container runtime, the underlying infrastructure, and the orchestrator (if one is used). An observable system will have the ability to collect logs and errors from all these elements and correlate them to enable easy troubleshooting.

Learn more in the detailed guide to exit codes

Kubernetes Errors

Kubernetes troubleshooting is the process of identifying, diagnosing, and resolving issues in Kubernetes clusters, nodes, pods, or containers. 

Here are some of the common errors you can encounter in Kubernetes:

  • CreateContainerConfigError—this error is usually the result of a missing Secret or ConfigMap. Secrets are Kubernetes objects used to store sensitive information like database credentials. ConfigMaps store data as key-value pairs, and are typically used to hold configuration information used by multiple pods. Learn more about CreateContainerError
  • ImagePullBackOff or ErrImagePull—this status means that a pod could not run because it attempted to pull a container image from a registry, and failed. The pod refuses to start because it cannot create one or more containers defined in its manifest. Learn more about ImagePullBackOff and ErrImagePull
  • CrashLoopBackOff—this issue indicates a pod cannot be scheduled on a node. This could happen because the node does not have sufficient resources to run the pod, or because the pod did not succeed in mounting the requested volumes. Learn more about CrashLoopBackOff
  • Kubernetes Node Not Ready—when a worker node shuts down or crashes, all stateful pods that reside on it become unavailable, and the node status appears as NotReady. Learn more about Kubernetes Node Not Ready

How can observability principles help resolve this error?

Container and node failures are often part of a bigger problem involving multiple components of a Kubernetes cluster. An observable system will have the ability to collect logs and errors from multiple levels of the Kubernetes environment—applications running within a failed container, container runtimes, pods, and the Kubernetes control plane—to enable rapid root cause analysis.

Learn more in the detailed guide to container exit codes

Git Errors

Git is a free and open source distributed code management and Version control system that is distributed under the GNU General Public License version 2. In addition to software version control, Git is used for other applications including configuration management and content management.

Git is the basis of development workflows in many DevOps organizations. It is also the foundation of a new and popular development process known as GitOps. Therefore, Git errors can disrupt development processes and, in organizations that practice continuous delivery or continuous deployment, directly impact end users.

Some of the common errors you can encounter in Git are:

  • Failed to push some refs to—a developer attempted to push committed code to an external git repository, and the code could not be committed successfully.
  • fatal: refusing to merge unrelated histories—a developer tries to merge two unrelated projects into a single branch. This error appears when the target branch’s commit histories and tags are incompatible with the pull request or clone.
  • Fatal: Not A Git Repository—a developer tried to execute a repository-specific command outside of the Git repository.

How can observability principles help resolve this error?

Git repositories must be connected to the same logging and monitoring systems used to oversee production environments. A Git error should be treated as a “first class citizen” error, just like a deployment error or downtime of a production component. This is because Git errors can disrupt software processes and impact end users.

Learn more in the detailed guide to Git Errors (coming soon)

Key Technologies and Tools for Observability

In the cloud native ecosystem, it is not possible to achieve observability without dedicated tools. Let’s review the main components of the modern observability stack. These include generic components—like log management—and components that assist with observability in specific use cases, such as security.

Log Management

The purpose of logging is to create a persistent record of application events. You can use a log file to view events happening in a system, such as failures or state changes. Log messages contain valuable information to help troubleshoot issues, by identifying changes that lead to a problem affecting a service, application, or infrastructure component.

Log management is the practice of collecting, organizing, and analyzing log data. Beyond its importance in troubleshooting, it can also provide the information necessary for auditing and compliance reports, identify trends over time, and protect sensitive information contained in logs. A good logging strategy focuses on normalizing machine data into a structured format, and creating alerts and notifications that can help administrators identify potential problems.

Logging plays an important role in applications of all sizes, but should be implemented with caution. It is important not to store or transmit unnecessary information—this can exhaust resources and can create compliance and security issues.

Application Performance Monitoring (APM)

Application Performance Monitoring (APM) can help you ensure that enterprise applications meet the performance, reliability, and user experience requirements of their users. APM tools can give you the data you need to find, isolate, and resolve issues that negatively impact applications and their end users.

An effective APM platform can monitor infrastructure, but goes beyond it to track the performance and reliability of applications. It can measure user experience, identify dependencies, and measure business transactions. APM tools collect data from a specific application or multiple applications on the network, typically including client CPU usage, memory requests, data throughput, and bandwidth usage.

Distributed Tracing

In a microservices architecture, a single user request may span multiple services, each potentially running on a different system or even a different geographical location. Understanding the flow of these requests across services and identifying where delays or failures occur can be challenging. This is where distributed tracing comes in.

Distributed tracing provides a way to track the journey of a request as it travels across various microservices. It helps identify slow or failing services, network delays, and other issues that can impact overall system performance.

Distributed tracing tools typically provide a visual representation of request flows, making it easier to understand the interactions between services and diagnose issues. However, implementing distributed tracing can be complex and requires careful instrumentation of applications.

Learn more in the detailed guide to distributed tracing

Real User Monitoring (RUM)

Real User Monitoring (RUM), also known as end-user monitoring or end-user experience monitoring, is usually provided as part of APM platforms, but can also be provided as a standalone solution. It is a method of measuring the actual experience of end users (as opposed to “synthetic” measurements).

RUM provides visibility into the user experience of your website or application by passively collecting and analyzing errors, access times, and other metrics from end users in real time. Real user monitoring helps developers understand how their code affects page performance, user experience, and other issues that impact end users in the field.


eBPF is a technology that allows sandboxed programs to run within the Linux operating system kernel. It is used to safely and efficiently extend the functionality of the kernel without changing kernel source code or loading kernel modules.

Historically, operating systems have been the ideal place to implement observability features, due to the kernel’s ability to monitor and control the entire system. However, the operating system kernel is difficult to modify due to its critical role in a computer system and the need to ensure stability and security.

eBPF changes the game by allowing programs to run within the operating system kernel. Application developers can run eBPF programs to add functionality to the operating system at runtime. The operating system uses a just-in-time (JIT) compiler and validation engine to ensure safety and execution efficiency as if the program was compiled natively. 

This resulted in a wave of eBPF-based projects covering a wide range of use cases, many of which are related to observability. eBPF makes it possible to collect metrics for obervability purposes much faster and more efficiently than other technologies.

Learn more in the detailed guide to eBPF


OpenTelemetry is an open source framework that collects and analyzes telemetry data from cloud-native applications. It provides vendor-agnostic APIs and SDKs that can work with any cloud native system. The framework makes it possible to instrument applications in order to better understand their performance and health characteristics.

OpenTelemetry lets you collect telemetry data from applications, underlying infrastructure, and services. You can use it to receive, process, transform and export the data. It is becoming the standard for machine data collection in the cloud native ecosystem.

Learn more in the detailed guide to OpenTelemetry

Zero Trust

The zero trust model is a security framework that removes implicit trust and enforces strong authentication of users and devices across networks. By restricting who has access to any part of your network or to any other system, you can significantly reduce the chances of hackers accessing sensitive assets.

Observability is just one aspect of zero trust, but it is a critical aspect, because zero trust security relies on having complete visibility over network traffic. Zero trust access systems need to inspect every request and receive data on the users, devices, and specific security context (such as the user’s location, the current time, and previous access attempts).

The zero trust model provides strong protection against some of the most severe cyber attacks, such as theft of corporate assets and identities. Adopting zero trust enables organizations to protect sensitive data, improving the ability to conduct compliance audits, reduce risk and detection time, and gain more control over cloud environments.

Learn more in the detailed guide to Zero Trust


Extended Detection and Response (XDR) is a new type of security platform that provides comprehensive protection against cyberattacks, unauthorized access and exploitation.

XDR solutions provide a proactive approach to threat detection and response. They provide visibility into all data, including endpoint, network, and cloud data, while applying analytics and automation to combat today’s increasingly sophisticated threats. 

XDR enables observability of security events across different parts of the IT environment. It brings together disparate systems and security tools, turning their raw data into a holistic picture of cybersecurity incidents. 

XDR enables cybersecurity teams to:

  • Proactively identify hidden, covert, and advanced threats
  • Track threats from any source or location within your organization
  • Increase the productivity of operations staff
  • Improve the speed and efficiency of incident response

Learn more in the detailed guide to XDR

Observability Best Practices

Here are important best practices that can help you succeed in your observability initiatives.

Optimize Logs

Log data enables DevOps teams to better understand systems and applications. The problem is that logs are often not constructed efficiently. Developers choose when and how to record log data, and in many cases, logs provide insufficient information or too much information to be useful. In some cases, logs don’t add enough context to make the information actionable. 

Log data bloat is a major problem for organizations. It can increase the time and cost of analysis, and cause data issues that make it more difficult to derive insights.

By optimizing log data, DevOps teams can prioritize key application metrics that need to be tracked. Make sure your logs are structured, descriptive, and track only important details such as unique user ID, session ID, timestamp, resource usage, and the specific event or error encountered. Connecting users to sessions is critical for many troubleshooting tasks.

Adopt a DevOps Culture

Organizational culture is critical to achieving a high level of observability in your application. Some strategic initiatives can only be realized if employees embrace the idea and align it with their work processes.

With a DevOps culture, every software team has responsibility over the full lifecycle of debuggable code—from design to deployment. This means they can take measures to instrument that code with useful logs, KPIs, and metrics. This improves the observability of the application, and gives operations teams the data they need to detect errors quickly, and even anticipate them ahead of time and prevent them.

When deploying code, it can be difficult to predict how it will behave and perform. In a DevOps culture, you can be prepared for whatever happens. If everyone is jointly responsible for your organization’s common goals, you can effectively handle unexpected application failures. It is important to ensure:

  • Developers understand how the organization treats success or failure of a software release.
  • Developers know what metrics are needed to measure success or failure and have an architecture that supports their collection.
  • Developers understand what dimensions they should optimize and improve over time to make the application better.

Creating and maintaining a DevOps culture not only improves application performance and observability, but also streamlines workflows, fosters collaboration, and increases productivity.

Enable Meaningful Reporting

Observability should not be considered a tool just for system administrators and DevOps practitioners. It should be viewed as a means of bridging the gap between IT and the business, providing meaningful reports, and recommending practical steps. 

These reports should inform IT staff of issues in real time, provide trend analysis, and help understand the business impact in a way that all stakeholders in the organization can understand.

Integrate With Automated Remediation Systems

Many of the problems found by observability systems are relatively low-level, predictable errors that can be easily resolved. Many system administrators already have tools to automatically fix issues, such as when a system needs to be patched or updated, or when additional resources need to be applied to a workload. 

By integrating observability systems into these existing, automated remediation tools, IT teams can more easily maintain an optimized environment. Where automation is not possible, IT staff can more easily focus on the problem and attend to it, because the “noise” of low-level issues has been eliminated.

Cloud Native Observability with Lumigo

Lumigo is cloud native observability tool that provides automated distributed tracing of microservice applications and supports OpenTelemetry for reporting of tracing data and resources. With Lumigo, users can:

  • See the end-to-end path of a transaction and full system map of applications
  • Monitor and debug third party APIs and managed services (ex. Amazon DynamoDB, Twilio, Stripe)
  • Go from alert to root cause analysis in one click
  • Understand system behavior and explore performance and cost issues 
  • Group services into business contexts

Get started with a free trial of Lumigo for your microservice applications

See Additional Guides on Key Observability Topics

Distributed Tracing

Authored by Lumigo

Microservices Monitoring

Authored by Lumigo


Authored by Lumigo

Serverless Monitoring

Authored by Lumigo


Authored by Codefresh

Cloud Monitoring

Authored by NetApp

Kubernetes Monitoring

Authored by Tigera


Authored by Tigera

Zero Trust

Authored by Tigera


Authored by Exabeam

Application Performance Monitoring

Authored by Coralogix

5xx Server Errors

Authored by Komodor

Exit Codes

Authored by Komodor

Cloud Security

Authored by Spot

Additional Observability Resources

Debug fast and move on.

  • Resolve issues 3x faster
  • Reduce error rate
  • Speed up development
No code, 5-minute set up
Start debugging free