doc.overops.com

Introduction to OverOps

Introduction

OverOps is a continuous reliability solution that enables companies who create software to ensure rapid code changes do not impact customer experience. Using OverOps teams can quickly identify, prevent, and resolve critical software issues. Unlike static code, log analyzers and APMs that rely on foresight, OverOps analyzes your code at runtime to produce optimized software data that tells when, where and why code breaks. OverOps runs in the cloud or on-premises, providing native support for microservices and containerized environments. With robust CI/CD integrations and open APIs, OverOps ensures software reliability from testing into production.

OverOps is easy to install and can be deployed in a variety of ways, including on VMs, the cloud, in containers, Pivotal Cloud Foundry (PCF) and more. In this Overview page, we'll explain about our deployment architecture(s) and where/how data is stored and accessed, and about the main components of the OverOps solution.

As such, OverOps enables enterprises to deliver on the promise of reliability by:

  • Arming developers with the ability find and resolve errors fast
  • Enabling QA teams to verify that that the code they approve is indeed up-to-speed
  • Providing DevOps teams with the ability to identify and prioritize critical anomalies in code
  • Ensuring that executives have the tools in hand to create a high-level strategy for technology initiation

OverOps does this by analyzing the code running across your environments to identify critical errors and anomalies and deliver complete root cause. It allows users to trace errors across the source code, determine the variables state, and debug level log statements for any error across the entire call stack. This data can be displayed using three different views:

Reliability

Your application and services are only as good as the reliability they provide your customers, so avoiding costly downtime is critical. OverOps’ real-time machine learning platform integrates into your entire software delivery life cycle, from QA to production, and analyzes your code as it’s executing to detect and prioritize issues automatically – ranging from new and resurfaced errors – to swallowed exceptions and performance slowdowns. From there we deliver True Root Cause with complete context to the right person so that your team can fix issues well before your users are affected.

Who Uses OverOps?

OverOps is more than a DevOps tool; it's designed to address the needs of many different types of users - including developers, QA, DevOps, and executive decision-makers.

  • Developers (which can include anyone from software developers, senior developers, leads, architects and VP engineering) are always under extreme pressure to deliver new features faster than ever (which, of course, creates more bugs) while still maintaining reliable code without issues.
  • QA teams are receiving code more often than ever, leaving them with limited time to test and verify
    issues, while they still have to answer for issues that they “missed”.
  • Operations - including DevOps, site reliability, performance and product support engineers - need to maintain uptime of applications, despite the fact code is released faster and is being tested less and is more prone to errors. They also need to create/maintain stabilization in a fast-moving world.
  • Executives at the highest level of buying power are the decision-makers and budget holders; these are the people under pressure from the board and CEO to innovate faster than the competition and create new streams of revenue for the company, while keeping customers happy and applications running. All this - while minimizing costs and expenses.

OverOps looks at the needs of all these stakeholders, and creates solutions that are designed to meet these needs at the application level.

Data and Logs are Key - But They're not Enough!

Data offers us the ability to extract and obtain insights that can be used to fuel business decisions. Typically, the more data you have the more insight you can gather. However, the software we deploy in modern applications also leaves massive amounts of information on the data center floor that nobody has really thought to capture (possibly because it seemed impossible to do so). This is the data that's created by the execution of the lines of code that powers just about everything we do. It’s the data that’s inside the engine, not just the exhaust we choose to emit.

Similarly, while we all know that logs are great - who has time to read them? We've relied on log data as the main source for gathering insight from our applications, and they're credibly useful but are not without limitation. While log files help identify when something has gone wrong, they only provide limited insight into “what” has actually happened.

OverOps has developed a unique approach to gathering machine data, one that changes the way we
think about log files and how we use them to both troubleshoot and to derive the overall quality of an application or service. OverOps combines static and dynamic analysis to collect complete contextual data for every error and exception thrown in an application with minimal performance impact, securely and without any requirement to modify code. Our solution is code-aware and delivers net new and structured machine data that provides granular detail about every error, its related application and the environment in which it was found. And, most significantly, OverOps is completely independent of log files. In fact, our technology allows us to precede the creation of a log file entry so we can augment them.

Easy Installation

Installing OverOps takes minutes in SaaS, Hybrid, or full On-Premises environments, and requires no changes to the code or the build. Every new code release or microservice is automatically monitored for new errors, and the relevant developer is notified through the selected channels (Slack, Hipchat , PagerDuty, Jira and more), when critical errors arise.

Security and Privacy

OverOps offers multiple layers of security to protect the privacy of the collected source code, the variables and data relating to your application, including PII Redaction, private encryption, flexible deployment options and data storage, user and access point control, and secure data transport. OverOps functions as a micro-agent operating between the JVM and processor, which allows it to run with very low CPU overhead both in staging and in production environments.

To learn more, take a couple of minutes to watch this video, or see the links below for more information.


Introduction to OverOps


Suggested Edits are limited on API Reference Pages

You can only suggest edits to Markdown body content, but not to the API spec.