New OverOps support for .NET enables enterprises to prevent rapid code changes from impacting the customer experience.
After working with engineering teams of the leading companies in Java technology and receiving multiple requests to support more languages, we are excited to announce that we are expanding our support to the .NET ecosystem.
Engineering teams building and delivering .NET Core and .NET Framework apps will now be able to leverage the power of OverOps to proactively identify, prevent, and resolve critical issues in their applications.
Unlike static code, log analyzers and APMs that rely on foresight, OverOps analyzes your .NET code at runtime to reveal when, where and why code breaks and provide all the details needed to resolve it in minutes.
Addressing Common Challenges in .NET
Over the last few months, we’ve been working with early adopters on adjusting the product to match the needs of companies who develop in .NET and face common challenges such as legacy code and moving to .NET Core.
Overcoming Issues in Legacy Code by Shifting Left
One of the teams that’s been helping us to fine-tune our .NET offering is working with a legacy .NET Framework application that was originally developed about 20 years ago. Most of the people that built the application are no longer with the company, and for the past 10 years, their focus has been on rolling out new features to please their large customers.
This prioritization of rapid development and delivery came at the price of quality and has led to significant technical debt which has been surfacing, along with reduced customer satisfaction, over the past year. The majority of their Sev1 issues today are discovered and reported by customers.
Unsurprisingly, their main goal was to increase code quality and eliminate customer-impacting issues. To do that, they leveraged OverOps’ ability to provide full visibility into code quality across the entire SDLC to implement a “shift left” strategy and resolve issues earlier in the development cycle.
With OverOps, they can proactively identify 100% of runtime errors (caught, uncaught and swallowed) in every environment, enabling them to block critical issues from reaching production and to more quickly resolve existing errors before customers report them.
Moving to .NET Core
With the release of .NET Core in 2016, many teams have begun to consider whether or not moving from .NET Framework is the right decision or not.
One of the teams that we’ve been working with has in fact begun migrating from .NET Framework on Windows to .NET Core Linux. So far, they have approximately 20% of their production services running on .NET Core.
With that, OverOps has helped the team overcome a couple of challenges. On the one hand, they were struggling with a lack of visibility into their legacy services and why they were failing. Plus, with the focus on migrating to .NET Core and continuing to provide innovative features and functionality for their customers, the team wanted to reduce time spent on error resolution.
What to Expect from OverOps for .NET?
OverOps now supports .NET Framework 2.0 to 4.8 and .NET Core 2.0 to 2.2 for Windows. Plus, support for .NET Core 3.0 is coming soon (more on that later).
With OverOps for .NET, users will get the same powerful runtime analysis and software data optimization that our Java teams enjoy, powered by OverOps’ Micro-Agent running on the CLR.
For all .NET applications, whether running in the cloud or on-premises, built as a monolith or distributed containers, OverOps enables teams to quickly identify, prevent and resolve critical software issues across the entire development and delivery lifecycle.
A key challenge that any team focused on building, delivering and/or managing .NET applications face is a lack of visibility into unknown errors. By analyzing code as it executes, OverOps is able to identify 100% of runtime errors including uncaught or swallowed exceptions.
Beyond identification, OverOps uses machine learning to classify errors as new, critical and/or increasing in frequency to help development teams focus their efforts on the issues that matter most.
All of this is done automatically without requiring code changes or additional configuration. Errors and service reliability scores are viewable in out-of-the-box dashboards powered by Grafana and can easily be integrated to other visualization tools to work seamlessly with any team’s existing tool stack.
As an extension of OverOps’ ability to identify 100% of runtime errors, teams can integrate with their CI/CD platforms to automatically block releases that are identified as having critical quality issues before the release is deployed to the next environment.
OverOps correlates every error to the relevant service and release enabling teams to track and monitor their quality over time.
Last, but certainly not least, is the depth and breadth of data that OverOps captures for each error. Our collection and optimization of software data is what enables us to not only identify but classify errors so teams are only alerted to critical issues and are not overwhelmed by useless noise.
The data that we provide for every error includes the complete source code, variable state and DEBUG-level logs (without adding logging verbosity). Plus, we provide insights into the process and container at the time of error including CPU, Heap and IO stats, threads (active, blocking and terminated) and the environment state of the host and container.
Direct access to this information directly from any error visualization tool helps to dramatically reduce MTTR for critical issues. The days of trying to reproduce errors, adding more extensive logging and redeploying are behind us. OverOps provides all data necessary to resolve errors in any environment without requiring any developer foresight or retroactive code changes.
Our current focus is to expand our .NET support on the Windows platform to include .NET Core 3.0. Naturally, the next step will be for us to expand our .NET support to the Linux platform as well.
Expanding our reach into .NET doesn’t stop with platform support. One of the reasons why our customers love us so much is that we work the way they work. Most of our customers integrate into their existing workflows to get their OverOps data in the tools they’re already using on a daily basis.
For us, offering .NET support means adding integrations to Microsoft tools to fit even better into the development cycle of our .NET customers. In this respect, our team is working to add OverOps promotion gates to Azure DevOps to automate detection of new issues and regressions throughout your delivery pipeline and prevent bad code promotion.
Getting Started with OverOps for .NET
OverOps customers interested in adding OverOps to your .NET applications, please get in touch with your customer success representative.