Modern application development has been transformed by the appearance of Cloud Services. Long gone are the days where each company kept a server computer in the basement. Today’s cloud-native development world makes deployment, hot-fixing and software maintenance infinitely cheaper and easier. However, the cloud presents entirely new challenges.
One such challenge is Production Debugging. A bug that is found in production costs infinitely more to fix than a bug found during development or testing. In the best case scenario, it will simply be much longer to find and solve. In the worst case, the bug will cause material damages and loss of customers.
While preventing such bugs as early as possible (“shifting left”) is ideal, the reality is that bugs are found in production all the time. Once a bug in production is discovered, it is paramount to solve it as quickly as possible. It is only sensible, given the relative the cost of a bug in production, which as shown in the graph above. The problem is that debugging production is notoriously difficult. Developers often resort to guesswork or adding logs and redeploying, which is not very effective.
OzCode’s Cloud Debugging as a Service transforms production debugging so it is as close as possible to local debugging.
OzCode Production Debugging
Production debugging starts when a problem is found in production.
This is usually a failure (crash or exception) that we can investigate with tools like Application Insights, Raygun or Sentry. These tools allow developers to see exception details, call stack, HTTP request details and so on.
OzCode goes a few steps further. With automatic integration to Application Insights, OzCode is able to extract the snapshot that was captured at the time of the failure and display the source code in a rich browser-based debugger, that acts just like in an IDE. OzCode creates a full debugger experience including full call Stack with source code, local values, expression evaluation and more.
But our new Debugger-as-a-Service platform goes much further that that. OzCode’s patented Time-Travel Debugging allows the developer to create a “what if” scenario by making live code changes, and solve the bug in the browser, without the need to redeploy or reproduce the scenario on their local machine.
In other words, OzCode transforms production debugging into an experience similar to the developer debugging locally in their IDE.
Integration to Application Insights from Azure DevOps (formerly VSTS)
For production debugging, OzCode needs to be installed as an Azure DevOps Extension.
Once installed, OzCode will integrate to Application Insights on your Azure Subscription and add new production debugging abilities:
- Display failures according by date, exception type, number of occurrences, or number of distinct users that were affected by it.
- Create interactive Debugging Sessions from failures.
- Assign Debugging Sessions to Azure Boards Work Items.
- Upload any crash dump and create a Debugging Session (more on that later).
So in addition to production debugging, OzCode allows managers to effectively manage production failures.
Creating and Collaborating in a Debugging Session
A Debugging Session can be created in several ways: from a failure in Application Insights, from a dump file that was captured in production (useful for desktop apps), and from the OzCode Visual Studio extension.
Any Debugging Session is secure and can be shared, privately, within your organization or to your Azure DevOps team. Much like file sharing in DropBox or OneDrive.
- Once shared, you can add comments to the session:
- You can place a comment that links to some particular variable value, at a particular point in time in the program’s execution, to help your colleagues understand the root cause of the bug:
- You can change the code and see the result of your changes:
- You can save your code changes as a code-fix proposal, which other developers can view and comment on. Think of an OzCode Debugging Session as a mixture of a Pull Request and Visual Studio Live Share for production debugging.
Collaborative Debugging from within Visual Studio
While the primary purpose of the OzCode Debugger-as-a-Service platform is to aid production debugging, it is also extremely useful for collaborative debugging and root cause analysis. This can save your team valuable time, especially in remote scenarios, and when dealing with regression bugs.
Any developer with the OzCode extension will be able to Share a Debugging Session from within Visual Studio.
The Debugging Session can be shared with specific people in your organization, attached to the Azure Boards (formerly VSTS) Work Item, and used for interactive debugging and collaboration. If a regression bug pops up – developers can revisit the shared interactive debugging session and view the correlated conversation, to gain an instant understand of what the bug was, what was the root cause, and how it was fixed.
Automatic Redaction of Personally Identifiable Information
One of the biggest concerns around Production Debugging is around protecting sensitive and personally-identifiable information. A huge advantage of the OzCode Debugger-as-a-Service platform is that it does not allow a developer to download a memory dump (and all the sensitive information contained therein), but rather, displays the information through a browser-based debugger that inherently supports redaction, and was designed with compliance to most stringent regulatory constraints in mind. The project administrator in Azure DevOps is able to control what information should be redacted, and view an audit trail of all the information developers were able to access through the production debugging experience.
Security is always a important, but the security consideration around production debugging cannot be understated. OzCode Cloud Debugging was designed and built with end-to-end security as the top priority.
With this new product, we hope to make production debugging faster and more productive than ever before. As our customer, you will have access to innovative patented production debugging technology. This includes:
- Interactive Debugging in the browser.
- Security as a first-class citizen
- Patented time-travel debugging experience
- Instant and transparent source code retrieval from a production failure or dump. No need to worry about pdbs!
- Collaboration including sharing, comments, links to specific faulty state, and code change proposals
- Automatically generate code to create unit tests from production scenarios
- Redaction of PII in production debugging
To sign up for the Cloud Debugger’s Beta waiting list, click here.