Introducing OzCode Cloud Debugging

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 InsightsRaygun 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.

Language Support

OzCode Cloud Debugging is only available for C# on .NET Framework and .NET Core. Support for JavaScript and TypeScript will be available in the future.

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 considerations

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.

Omer Raviv


Keep your code in good shape!

Subscribe to our blog and follow the latest news in the .NET debugging industry

Ready to Dive into Your Prod Code?

Easy debugging with full time-travel data

The Exception

A Quarterly Roundup

Subscribe to our quarterly newsletter and hear all about what’s happening around debugging with Ozcode

Share on facebook
Share on twitter
Share on linkedin
Share on email

Recent Posts

Follow Us

Join Ozcode YouTube Channel

Let’s start debugging, it’s free!

Thanks for downloading the OzCode trial!

You’re well on your way to making C# even sharper.

If your download doesn’t start automatically , please use this direct link.

If you’d like to install OzCode but don’t have
administrative privileges on your machine, please contact us.

Get Started for FREE!

Ozcode Logo

This website uses cookies to ensure you get the best experience on our website.