GitOps and Chronosphere: Improving observability workflows

A group of business people using GitOps to hold wooden gears together while implementing observability workflows, with the help of Chronosphere.
ACF Image Blog

When it comes to managing complex distributed systems, GitOps has emerged as a popular methodology in recent years.



The GitOps approach uses Git repositories as the single source of truth for infrastructure-as-code, which ensures all changes to code are tracked — this makes updates straightforward and provides robust version control in case a rollback is needed. GitOps offers:

  • A standardized workflow for application development
  • Enhanced security by setting application requirements upfront
  • Improved reliability with visibility and version control through Git and infrastructure-as-code
  • Consistency across any cluster, cloud, or on-premises environment

The customer landscape around GitOps is evolving rapidly. Organizations that have adopted a DevOps culture are now looking to GitOps to further enhance their rate of innovation in applications and code because the methodology lets developers deploy code more quickly, more reliably, and with less manual effort. By leveraging Git-based workflows, GitOps extends the application development process to deployment, application lifecycle management, and infrastructure configuration.

The GitOps approach ensures that every change throughout the application lifecycle is traceable in the Git repository, which in turn makes the app lifecycle auditable. Such a framework allows developers to code at their pace without waiting for resources, while operations teams gain visibility into changes, enhancing overall security.

Chronosphere: Your partner in the GitOps journey

At Chronosphere, we’ve crafted features that don’t just align with GitOps principles but also directly enhance the everyday developer experience. Some great examples are:

  • Terraform Provider for Chronosphere
  • UI Interactivity
  • Code Config
  • Version History

With these features, developers can edit monitors in the UI, preview any changes, and generate the proper code. They don’t need to know the corresponding syntax for Chronoctl, Public API, or an infrastructure-as-code tool, such as Terraform. This means developers can code faster, safer, and automatically generate an auditable repository. Here’s more explanation about what these features do.

Terraform provider for Chronosphere

The Chronosphere provider allows you to build Terraform configurations to manage your resources from monitors to dashboards. This provider offers parity with Chronosphere’s existing API library such that all your modifications can go through Git and be appropriately tracked.

Since users can still make edits to configurations via the UI or API, now can we ensure a single source of truth. Chronosphere adheres to this by ensuring that changes made via Terraform override any modifications made through the UI or API. This approach guarantees that the state of the infrastructure is always synchronized with the code configuration found in the user’s git repository. This minimizes the risk of configuration drift and provides a consistent and predictable monitoring environment.

Chronosphere has taken strides to integrate GitOps with users’ workflows to ensure that they are able to get the most value out of both the UI and the GitOps flow.

UI Interactivity

While we acknowledge the benefits of GitOps and Terraform, we also recognize the value of the UI in providing an interactive way to create and edit Chronosphere entities. The UI allows users to visualize the impact of their changes and make subsequent modifications to reach the desired experience.

Code Config

To bridge the gap between UI interactivity and GitOps principles, Chronosphere offers an innovative feature called Code Config (rolled out to Monitors initially). The Edit Monitor UI page now makes it easier for customers to build and update a monitor by using the visual editing experience – instead of just a command line interface.

It allows customers to make changes in the UI, see the preview of the changes, and export the necessary configuration code with Code Config to persist in the customer’s system of record (e.g. GitHub) before taking it through the GitOps workflow.

This new flow enables customers to:

  • easily discover Chronosphere’s monitor capabilities
  • get immediate visual feedback
  • feel more confident about the changes they’re making
  • get valid configuration code
  • ultimately reduce the friction in the developer experience

Enhanced visibility through Version History

As organizations rely on myriad data sources and numerous contributors, maintaining visibility and accountability becomes paramount. Chronosphere’s introduction of Version History for Monitors addresses this challenge.

The Version History UI page means users can now view and understand how monitors have evolved over time directly in the product. This enhancement is valuable for users who are trying to follow an application’s life cycle in order to understand its current state. Users can also discover the root cause more quickly during incident management.

Users can view past configuration versions, compare between different versions, and easily understand when changes took place. It supports viewing both changes that came directly within the UI and from external sources via a GitOps workflow. This new feature enables users to:

  • easily discover a Chronosphere’s monitor history
  • get immediate visual understanding of version differences
  • access past configuration code
  • ultimately enhance the developer experience

Sally’s Challenge

Let’s look at a hypothetical Chronosphere user — a DevOps engineer named Sally — to understand how Chronosphere’s features can transform observability workflows and how the Git repository helps.

Sally is a DevOps engineer at a fast-growing tech startup. She’s responsible for managing the monitoring configurations for several applications. With the rapid pace of development and frequent changes, Sally often finds herself juggling between the UI for quick edits and Terraform configurations for more structured, version-controlled changes. She needs a way to bridge her immediate UI changes with the robustness of GitOps principles.

UI Interactivity: Sally’s new best friend

One day, Sally discovers Chronosphere’s Code Config feature. This means she can use the familiar visual editing experience within the Chronosphere UI to preview changes, and then automatically generate configuration in her preferred format.

To make a change to a monitor, she previews her changes in real-time with the Chronosphere UI. This immediate feedback allows her to understand the potential impact of her modifications, ensuring she makes informed decisions.

But the real magic happens when she’s done. Instead of her changes being confined to the UI, she can now export these modifications as a Terraform configuration. This means she can apply her changes through her system of record via Git, ensuring that her quick UI edits are still in line with GitOps principles.

Version History: Sally’s safety net

A week later, Sally faces an unexpected challenge. One of the applications starts behaving erratically, and she suspects a recent change in monitoring configurations might be the culprit. In the past, tracing back changes would have been a tedious task, because she would have spent time manually comparing lines of code. But with Chronosphere’s Version History for monitors, it’s a breeze. The Version History function provides a log of any code changes to her monitors so she can easily see any updates made over the code’s lifespan.

Sally quickly pulls up the Version History and can see a clear, chronological record of all changes made to the problematic monitor. She identifies a recent modification and gets insights into the source of the modification, be it from the UI, Terraform, or API.

Armed with this information, Sally quickly collaborates with her team, rolls back to a previous stable configuration, and resolves the issue. The ability to trace back changes and understand their context proves invaluable, turning what could have been hours of troubleshooting into a quick fix.

Benefits of using Chronosphere for GitOps: Better observability workflows:

For Sally, and countless users like her, Chronosphere’s features are more than just tools; they’re workflow enhancers. Whether it’s the seamless fusion of UI interactivity with GitOps principles or the safety net provided by the version history, Chronosphere ensures that users are always equipped to handle the challenges of modern infrastructure management with confidence and efficiency.

Closing Thoughts

At Chronosphere, we fully embrace and support the GitOps workflow that customers are striving for but also want to ensure that the developer experience is kept intact and even enhanced. Through our efforts with the Terraform providers and recent capabilities of Code Config and Version History, we will be able to enhance the developer experience.

Stay tuned to this space because there will be more coming in the future on the Chronosphere and GitOps front!

Share This:
Table Of Contents
Most Recent:

Ready to see it in action?

Request a demo for an in depth walk through of the platform!