Product Direction - Monitor

The following page may contain information related to upcoming products, features and functionality. It is important to note that the information presented is for informational purposes only, so please do not rely on the information for purchasing or planning purposes. Just like with all projects, the items mentioned on the page are subject to change or delay, and the development, release, and timing of any products, features or functionality remain at the sole discretion of GitLab Inc.

Mission

The mission of the GitLab Monitor stage is to provide feedback on the health and performance of your system so that you can decrease the frequency and severity of incidents.

Landscape

The Monitor stage directly competes in several markets defined within our Ops Section, including Application Performance Monitoring (APM), Log Management, Infrastructure Monitoring, IT Service Management (ITSM), Digital Experience Management (DEM) and Product Analytics. The total addressable market for the Monitor stage is projected to be $2.7 billion by 2024.

All of these markets are well-established and crowded, with winning companies achieving spectacular growth as businesses continue to shift online.

Successful vendors, such as market leader Datadog are leveraging a platform strategy to expand their markets (see DataDog's acquisition of Undefined Labs to expand beyond production applications to provide code insights during development, or their expansion to incident management in 2020). Competition among market leaders today is also geared toward making the whole stack observable for enterprises. New Relic's updated business model reflects the need for vendors to capture increasing footprint (and spend) of enterprises while enabling future growth by making a significant part of their business free.

Vision

The vision of the Monitor stage is to enable DevOps team to operate their application by enabling monitoring, observability, incident response, and feedback all within a single application, GitLab.

Everyone needs monitoring. We want everyone to be able to access it, without an exorbitant cost that constantly needs to be monitored, and without specialized skills to use the tools in order to get the benefit. In short, we would like Monitoring to be commoditized and democratized.

Strategy

To achieve our vision, our strategy is to:

Focus first on user adoption and dogfooding of Incident Management
Strengthen bi-directional product tie-in to other GitLab stage capabilities
Build a boring Monitor/Observability solution that enables customers to start using GitLab and move away from expensive Monitoring vendors

Opportunities

Instrumentation is commoditized. GitLab will not need to invest in agents since OpenTelemetry and most vendor agents are all open source.
With development shifting cloud-native and the massive community driven investment in tools and patterns, the opportunity to build boring solutions on top of the cloud-native solutions plays right to GitLab's strength.
Out-of-the-box monitoring capabilities saves time and money and lowers the bar on the expertise required for enterprises and start-ups. The ease by which most users can start monitoring their service, using established vendors, such as DataDog or New Relic, and newer competitors like Honeycomb, is something we should strive to emulate.
Monitoring is traditionally for production, there are opportunities to shift monitoring tools and techniques left.
Monitoring vendors are considered, in general, to be expensive. We can compete on cost when monitoring is part of the GitLab single application.

Challenges

Monitoring vendors offer generous free tiers (e.g. here and here) for smaller companies and complete solutions for enterprises.
Huge investments are made by market leaders. Market leaders are also expanding the scope of their solution. This makes them more sticky with their customers.

What's next

The Monitor surface area is large. Rather than continue to pursue bringing multiple products within the monitor purview to market concurrently, GitLab has consolidated the majority of its current focus to Incident Management. This allows us to complete the smart feedback loop within a single DevOps platform as a first priority. With GitLab Incident Management's development timeline, our users will benefit from the advantage of enabling collaboration for incident response within the same tool as their source code management, CI/CD, plan, and release workflows - all within the same tool. This most effectively positions GitLab to gain market traction and user adoption.

The details of what the Monitor Group is currently working on is listed in Incident Management Direction.

Changing direction on Monitoring and Observability

GitLab users previously can monitor their services and application by leveraging GitLab to install Prometheus to a GitLab managed cluster. Similarly, users can also install the ELK stack to do log aggregation and management. The advantage of using GitLab with these popular tools is that users can collaborate on monitoring in the same application they use for building and deploying their services and applications. Furthermore, developers, who do not use, or potentially because they don't have access to their organizations monitoring tool, seeing metrics for their service and cluster metrics where their application run is extremely useful.

However, we believe that our solution is niche and reliant on a foundation that will be removed as we are deprecating GitLab Managed Apps.

What we've learned since that makes this particular strategy challenging are the following:

Not working by default - GitLab has to first manage the cluster, get users to install additional applications, setup Prometheus exporters, before being able to see a chart. Compared to a vendor that has an agent that auto instruments an application, the high bar is a barrier for adoption.
Mostly self-service - Users are responsible for managing, scaling, and operating their Prometheus fleet, and ELK stack in order to use GitLab metrics and logging. Not having to manage and pay for the associated infrastructure and people are some main reasons organizations outsource these tasks to vendors. When an organization chooses to manage monitoring on their own, many are perfectly happy just using the open-source tools on their own, without GitLab as an additional layer that does not provide additional value currently.
Wrong market - We targeted SMBs to use our tools as a cheaper solution relative to other vendors. The problem is the total cost of ownership was not necessarily lower. Furthermore, since GitLab's solution was based on having GitLab manage the customer's Kubernetes cluster, and there wasn't necessarily a significantly large overlap between SMB customers and those that used Kubernetes, it meant our solutions was constrained to a smaller target audience. We are intentionally shifting our strategy to account for what we learned:
We are removing GitLab Managed Apps
Start with a SaaS first.
Leverage OpenTelemetry and potentially other open-source agents for auto-instrumentation. Potentially leverage the GitLab Kubernetes Agent to setup exporters.
Lean into having an integrated monitoring/observability tool all within GitLab. We will have limited bandwidth to make progress in this space within our development groups. In FY22, we are creating a Single-Engineer-Group to help us kickstart this effort.
Leverage OpenTelemetry and potentially other open-source agents for auto-instrumentation. Potentially leverage the GitLab Kubernetes Agent to setup exporters.

Performance Indicators (PIs)

Our Key Performance Indicator for the Monitor stage is the Monitor SMAU (stage monthly active users).

The Monitor SMAU is based on the Incident Management category. It is the count of unique users that interact with alerts and incidents. This PI will inform us if we are on the right path to provide meaningful incident response tools.