{"id":9427,"date":"2017-08-22T05:39:24","date_gmt":"2017-08-22T05:39:24","guid":{"rendered":"http:\/\/abstracta.us\/?p=9427"},"modified":"2025-05-05T21:20:46","modified_gmt":"2025-05-05T21:20:46","slug":"debugging-production-overops","status":"publish","type":"post","link":"https:\/\/abstracta.us\/blog\/software-testing\/debugging-production-overops\/","title":{"rendered":"Debugging in Production with OverOps"},"content":{"rendered":"<p><!-- Go to www.addthis.com\/dashboard to customize your tools --><script src=\"\/\/s7.addthis.com\/js\/300\/addthis_widget.js#pubid=ra-58d80a50fc4f926d\" type=\"text\/javascript\"><\/script><\/p>\n<h1>OverOps, the self-proclaimed &#8220;God mode for production code&#8221;<\/h1>\n<p><span style=\"font-weight: 400;\">We are happy to share a new tool that we are excited about here at Abstracta, OverOps! Why? Well, simply put, it makes it easy to see where, when, and why your code breaks in production. My colleagues first learned about it at the Velocity Conference this past June in Santa Clara, and more recently, we\u2019ve been getting to know how it works more in-depth. In this post, I\u2019ll share how it can be used for debugging in production. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">OverOps captures errors and exceptions in any application that works in the Java Virtual Machine, such as Java, Scala, Closure, etc. and records information that facilitates the reproduction and resolution of the problem. Among other things, it registers the line of code where the error is reproduced as well as the values of the variables and attributes at that moment. What\u2019s great is that OverOps plans to add more languages in the future and by the end of the year, it will be ready for .NET. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">This two minute video provides a quick overview of OverOps:<\/span><\/p>\n<p style=\"text-align: center;\"><iframe src=\"https:\/\/www.youtube.com\/embed\/xb8eP08b2iQ\" width=\"560\" height=\"315\" frameborder=\"0\" allowfullscreen=\"allowfullscreen\"><\/iframe><\/p>\n<h2><span class=\"ez-toc-section\" id=\"How_to_Install_OverOps\"><\/span>How to Install OverOps<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><span style=\"font-weight: 400;\">The installation process varies between operating systems, but in general, it\u2019s very simple. First, you have to create an account on the <\/span><a href=\"https:\/\/www.overops.com\/\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">OverOps<\/span><\/a><span style=\"font-weight: 400;\"> website and follow the installation steps from there. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">For example, if you are installing on Windows:<\/span><\/p>\n<ol>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Download and run the installer (an executable), which installs fairly fast. You\u2019ll have to put a secret key to link the OverOps server to the machine where the application to be monitored is housed.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Connect to the Java Virtual Machine. For that you have to add &#8220;-agentlib: TakipiAgent&#8221; to the Java arguments when you open the application.<\/span><\/li>\n<\/ol>\n<p><span style=\"font-weight: 400;\">After completing these two steps, the tool should work. In the tool installation window (in step 2) there is a button to check the connectivity of OverOps with the application to be monitored:<\/span><\/p>\n<p><a href=\"http:\/\/abstracta.us\/wp-content\/uploads\/2017\/08\/Screen-Shot-2017-08-21-at-10.28.12-PM.png\"><img decoding=\"async\" class=\"alignnone size-full wp-image-9428\" src=\"http:\/\/abstracta.us\/wp-content\/uploads\/2017\/08\/Screen-Shot-2017-08-21-at-10.28.12-PM.png\" alt=\"test installation\" width=\"146\" height=\"37\" \/><\/a><\/p>\n<p><span style=\"font-weight: 400;\">If after completing these steps, it still isn\u2019t working, check if the Java Virtual Machine took the -agentlib: TakipiAgent argument when opening (with JConsole for example or command line) or see that the downloaded program has been installed correctly in step 1.<\/span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"Monitoring_with_OverOps\"><\/span>Monitoring with OverOps<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><span style=\"font-weight: 400;\">The OverOps main page presents a grid where all the exceptions recorded so far are shown, grouping all the times that the same exception occurs in a single element. They can be ordered according to several criteria, the most useful being:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Number of times error occurred<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Percentage of error versus the total number of calls of that code<\/span><\/li>\n<\/ul>\n<p><a href=\"http:\/\/abstracta.us\/wp-content\/uploads\/2017\/08\/overops-1-768x370-1-min-1.png\"><img decoding=\"async\" class=\"alignnone size-full wp-image-9434 aligncenter\" src=\"http:\/\/abstracta.us\/wp-content\/uploads\/2017\/08\/overops-1-768x370-1-min-1.png\" alt=\"OverOps screen\" width=\"768\" height=\"370\" \/><\/a><\/p>\n<p><span style=\"font-weight: 400;\">You can also group the errors according to:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">The server<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">The application<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">The deployment made<\/span><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400;\">If you click on one of the particular errors, you can see useful information to correct them, including:<\/span><\/p>\n<ul>\n<li><span style=\"font-weight: 400;\">The call stack where the trace of executed methods is displayed until it reaches the error<\/span><\/li>\n<li><span style=\"font-weight: 400;\">The code executed, in particular, the line where the error occurs is highlighted<\/span><\/li>\n<li><b><b>The state and value of the variables at the time of the error<\/b><\/b><\/li>\n<li><span style=\"font-weight: 400;\">Status of the JVM (memory, threads, etc.)<\/span><\/li>\n<li><span style=\"font-weight: 400;\">The last lines of the output log, which will surely be related to what occurred<\/span><\/li>\n<\/ul>\n<p><a href=\"http:\/\/abstracta.us\/wp-content\/uploads\/2017\/08\/overops-2-768x399-1-min-1.png\"><img decoding=\"async\" class=\"size-full wp-image-9436 aligncenter\" src=\"http:\/\/abstracta.us\/wp-content\/uploads\/2017\/08\/overops-2-768x399-1-min-1.png\" alt=\"OverOps screenshot\" width=\"768\" height=\"399\" \/><\/a><\/p>\n<p><span style=\"font-weight: 400;\">A helpful feature that it provides for a production environment is that it enables you to generate alerts for developers so that they can investigate and fix problems as soon as possible.<\/span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"Can_it_Actually_Be_Used_in_Production\"><\/span>Can it <em>Actually<\/em> Be Used in Production?<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><span style=\"font-weight: 400;\">It\u2019s important to highlight here that all of this can be done at very little cost, and since it\u2019s not intrusive, it can be done in production. OverOps is low storage and ensures that it never adds more than 1% network overhead. In the case that it detects it would consume more, it cancels the storage of information. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">OverOps is similar to <\/span><a href=\"https:\/\/msdn.microsoft.com\/en-us\/library\/dd264915.aspx\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">Microsoft\u2019s Intellitrace<\/span><\/a><span style=\"font-weight: 400;\">, but with a more efficient mechanism for instrumentation. The problem with Intellitrace and debugging in production is addressed in <\/span><a href=\"https:\/\/blogs.msdn.microsoft.com\/devops\/2012\/03\/16\/running-intellitrace-on-applications-in-production\/\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">this post<\/span><\/a><span style=\"font-weight: 400;\">:<\/span><\/p>\n<blockquote><p><i><span style=\"font-weight: 400;\">\u201cWith either plan, we recommend that you start IntelliTrace data collection, reproduce the problem, and then stop collection. You can take resulting log that IntelliTrace creates, open it in Visual Studio 11 Ultimate, and analyze it.\u201d<\/span><\/i><\/p><\/blockquote>\n<p><span style=\"font-weight: 400;\">Essentially, Microsoft recommends only activating Intellitrace to get the data so you can analyze it later in Visual Studio. Instead, OverOps is designed for production, enabling you to analyze the problems in the web console (so it\u2019s not necessary to do the analysis in a development IDE).<\/span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"The_Verdict_for_Testers\"><\/span>The Verdict for Testers<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><span style=\"font-weight: 400;\">We find this to be an interesting monitoring tool, different from those we\u2019ve typically used in our performance testing arsenal, <\/span><b>that can add value in projects where a production emergency has to be solved.<\/b><span style=\"font-weight: 400;\"> It reduces the need to reproduce errors, and you can solve them directly from the code since you have the status info of the variables related to the problem.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">To take full advantage of it, testers should use it in conjunction with developers, since the most relevant information refers to the application code. This is yet another way testers can be involved with tasks close to the code, which relates to what we wrote about regarding the hands-on <\/span><a href=\"http:\/\/abstracta.us\/blog\/software-testing\/what-is-a-qe\/\"><span style=\"font-weight: 400;\">role of the quality engineer<\/span><\/a><span style=\"font-weight: 400;\">. It could also be very useful in the testing stage for finding and fixing functional bugs.<\/span><span style=\"font-weight: 400;\"><br \/>\n<\/span><span style=\"font-weight: 400;\"><br \/>\n<\/span><strong>If you want to try it, we can <a href=\"https:\/\/abstracta.us\/contact-us\">lend a hand<\/a> and even contact the OverOps team.<\/strong><\/p>\n<p><span style=\"font-weight: 400;\">Tell us, have you used it or plan on trying it? Let us know what you think of this tool!<\/span><\/p>\n<hr \/>\n<h2><span class=\"ez-toc-section\" id=\"Recommended_for_You\"><\/span>Recommended for You<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><a href=\"http:\/\/abstracta.us\/blog\/software-testing\/what-is-a-qe\/\"><span style=\"font-weight: 400;\">[Infographic] What is a QE?<br \/>\n<\/span><\/a><a href=\"http:\/\/abstracta.us\/blog\/performance-testing\/performance-testing-in-production\/\"><span style=\"font-weight: 400;\">Performance Testing in Production<\/span><\/a><\/p>\n<p>&nbsp;<\/p>\n","protected":false},"excerpt":{"rendered":"<p>OverOps, the self-proclaimed &#8220;God mode for production code&#8221; We are happy to share a new tool that we are excited about here at Abstracta, OverOps! Why? Well, simply put, it makes it easy to see where, when, and why your code breaks in production. My&#8230;<\/p>\n","protected":false},"author":20,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1,61],"tags":[68,143],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v14.0.2 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Debugging in Production with OverOps | Abstracta<\/title>\n<meta name=\"description\" content=\"OverOps makes it easy to see where, when, and why your code breaks. It&#039;s a great tool for debugging in production and in this post, we&#039;ll see why.\" \/>\n<meta name=\"robots\" content=\"index, follow\" \/>\n<meta name=\"googlebot\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<meta name=\"bingbot\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Debugging in Production with OverOps | Abstracta\" \/>\n<meta property=\"og:description\" content=\"OverOps makes it easy to see where, when, and why your code breaks. It&#039;s a great tool for debugging in production and in this post, we&#039;ll see why.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/\" \/>\n<meta property=\"og:site_name\" content=\"Blog about AI-powered quality engineering for teams building complex software | Abstracta\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/AbstractaQA\/\" \/>\n<meta property=\"article:published_time\" content=\"2017-08-22T05:39:24+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-05-05T21:20:46+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/abstracta.us\/wp-content\/uploads\/2017\/08\/Debugging-in-Production-with-OverOps-4-min.png\" \/>\n\t<meta property=\"og:image:width\" content=\"560\" \/>\n\t<meta property=\"og:image:height\" content=\"315\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@AbstractaUS\" \/>\n<meta name=\"twitter:site\" content=\"@AbstractaUS\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebSite\",\"@id\":\"https:\/\/abstracta.us\/blog\/#website\",\"url\":\"https:\/\/abstracta.us\/blog\/\",\"name\":\"Blog about AI-powered quality engineering for teams building complex software | Abstracta\",\"description\":\"AI-powered quality engineering\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":\"https:\/\/abstracta.us\/blog\/?s={search_term_string}\",\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"ImageObject\",\"@id\":\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/#primaryimage\",\"inLanguage\":\"en-US\",\"url\":\"http:\/\/abstracta.us\/wp-content\/uploads\/2017\/08\/Screen-Shot-2017-08-21-at-10.28.12-PM.png\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/#webpage\",\"url\":\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/\",\"name\":\"Debugging in Production with OverOps | Abstracta\",\"isPartOf\":{\"@id\":\"https:\/\/abstracta.us\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/#primaryimage\"},\"datePublished\":\"2017-08-22T05:39:24+00:00\",\"dateModified\":\"2025-05-05T21:20:46+00:00\",\"author\":{\"@id\":\"https:\/\/abstracta.us\/blog\/#\/schema\/person\/01d9308f078567d3a864671543fb9966\"},\"description\":\"OverOps makes it easy to see where, when, and why your code breaks. It's a great tool for debugging in production and in this post, we'll see why.\",\"breadcrumb\":{\"@id\":\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"item\":{\"@type\":\"WebPage\",\"@id\":\"https:\/\/abstracta.us\/blog\/\",\"url\":\"https:\/\/abstracta.us\/blog\/\",\"name\":\"Home\"}},{\"@type\":\"ListItem\",\"position\":2,\"item\":{\"@type\":\"WebPage\",\"@id\":\"https:\/\/abstracta.us\/blog\/testing-tools\/\",\"url\":\"https:\/\/abstracta.us\/blog\/testing-tools\/\",\"name\":\"Testing Tools\"}},{\"@type\":\"ListItem\",\"position\":3,\"item\":{\"@type\":\"WebPage\",\"@id\":\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/\",\"url\":\"https:\/\/abstracta.us\/blog\/testing-tools\/debugging-production-overops\/\",\"name\":\"Debugging in Production with OverOps\"}}]},{\"@type\":[\"Person\"],\"@id\":\"https:\/\/abstracta.us\/blog\/#\/schema\/person\/01d9308f078567d3a864671543fb9966\",\"name\":\"Andrei Guchin, Performance Hub Lead at Abstracta\",\"image\":{\"@type\":\"ImageObject\",\"@id\":\"https:\/\/abstracta.us\/blog\/#personlogo\",\"inLanguage\":\"en-US\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/ead6d46d807b34b0ab1af5cc298f73cc?s=96&d=blank&r=g\",\"caption\":\"Andrei Guchin, Performance Hub Lead at Abstracta\"},\"description\":\"Performance Engineer, Abstracta\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","_links":{"self":[{"href":"https:\/\/abstracta.us\/blog\/wp-json\/wp\/v2\/posts\/9427"}],"collection":[{"href":"https:\/\/abstracta.us\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/abstracta.us\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/abstracta.us\/blog\/wp-json\/wp\/v2\/users\/20"}],"replies":[{"embeddable":true,"href":"https:\/\/abstracta.us\/blog\/wp-json\/wp\/v2\/comments?post=9427"}],"version-history":[{"count":18,"href":"https:\/\/abstracta.us\/blog\/wp-json\/wp\/v2\/posts\/9427\/revisions"}],"predecessor-version":[{"id":17507,"href":"https:\/\/abstracta.us\/blog\/wp-json\/wp\/v2\/posts\/9427\/revisions\/17507"}],"wp:attachment":[{"href":"https:\/\/abstracta.us\/blog\/wp-json\/wp\/v2\/media?parent=9427"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/abstracta.us\/blog\/wp-json\/wp\/v2\/categories?post=9427"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/abstracta.us\/blog\/wp-json\/wp\/v2\/tags?post=9427"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}