BMC AppSight Problem Resolution System for Windows / .NET
[This article is sponsored by Peningo Systems, Inc., a provider of BMC Remedy Consulting Services on a nationwide basis. For more information on Peningo Systems, please go to the Peningo BMC Consultants page ]
This white paper discusses how the BMC AppSight Problem Resolution System automates the problem resolution process in Windows / .NET environments, and outlines the most common application problems. We at Peningo Systems recommends this White Paper to any Windows / .NET Applications Developer or QA Engineer whose looking for an automated problem resolution process will allow to build more new functionality, execute more tests, and accelerate the release of applications — all while maintaining or reducing project costs.
About BMC AppSight Problem Resolution System:
The BMC AppSight Application Problem Resolution System optimizes application development by automating the problem resolution process, which traditionally consumes up to 40 percent of the time during development, testing, and maintenance.
BMC AppSight Application Problem Resolution System uses software-only technology that is analogous to a black box flight recorder on an airplane, automatically capturing full problem data — from user actions to source code execution. The system cuts 50 percent of time spent on root cause analysis by:
> Automating the information-gathering step. All relevant data is gathered in a single, automated step.
> Eliminating the need to recreate the environment and
- reproduce the exact problem scenario. Full root cause
- information is captured, regardless of the problem type.
> Accelerating the analysis step. Developers can now
diagnose the actual problem the first time — and not just
reproduce the symptom.
BMC AppSight Application Problem Resolution System captures every problem in testing, and can be activated on demand in the support phase to gather full problem information in the production environment or at remote end-user sites.
Through process automation, BMC AppSight Application Problem Resolution System enables development organizations to build more new functionality, execute more tests, and release applications faster — all while maintaining or reducing project costs.
To view this White Paper please click the following link:
http://peningoblog.com/bmc/downloads/appsight_dotnet.pdf
About Peningo Systems:
Peningo Systems and it founders have been involved in IT Consulting for over 30 years. Peningo Systems provides IT Consultants at the Professional Service level on a nationwide basis supporting many areas including:
- WebSphere Portal
- Tivoli Consultants
- WebSphere Commerce Consulting
- WebSphere Eclipse Development
- WebSphere MQ
- System Security Architecture
- Tivoli Access Manager Consulting
- Tivoli Identity Manager Consulting
- Tivoli Storage Manager Consulting
- DB2 – UDB,
- SAP Consulting
- Remedy Consulting
- BMC Consulting
- Peregrine / HP Openview AssetCenter and ServiceCenter
- J2EE based systems architecture and development.
- JDA Software / Manugistics Consulting
- Blaze Advisor Consulting
- Hyperion Consulting
If your organization is seeking to retain a AppSight Resource, please consider Peningo Systems. Click here to view the profile of one of the Peningo
Systems AppSight Consultants.
To see Peningo Systems areas of expertise, please go to the Peningo Technical Areas page or go to the Peningo BMC Consultants page.
The following are excerpts from the White Paper published by BMC:
Problem Resolution – A Major Time Consumer
In most projects, more than half of the total software project time is spent on testing. This involves a wide variety of tests, including unit testing, functional testing, integration testing, system testing, load testing, and user acceptance testing. During the testing period, just about all of a developer’s time is spent on diagnosing defects reported by the testing teams. At the same time, testers spend the bulk of their time gathering information and documenting defects. These activities make up the problem resolution process.
Developers may also get involved in the resolution of problems detected after the software has been released. While only a small percentage of all problems are escalated to the development team, these problems often require a considerable amount of time to resolve, consequently disrupting project plans.
Overall, development organizations may spend up to 40 percent of their time on problem resolution, a frustrating process that adds no value to the business.
Inefficiencies of the Problem Resolution Process
The problem resolution process consists of two steps: root cause analysis and problem fix. Typically, the vast majority of the time that developers spend in application problem resolution is spent on root cause analysis.
Root cause analysis presents a challenge because the documented symptom does not usually point to the source of the problem. For example, during integration testing, a particular transaction may not execute. Potential causes of the failure are many and varied, and may include a source code bug, an operating system service failure, a network problem, improper configuration, or a combination of these.
In performing root cause analysis, developers and testers (during development) and developers and support teams (during maintenance) typically collaborate in an iterative, cumbersome, three-step process that is often based on trial and error:
> Gather problem information > Recreate the problem scenario in a disparate, controlled
environment > Analyze the recreated problem to determine its root cause
Since these tasks are performed manually, the problem resolution process is inefficient and time consuming.
Figure 1. BMC AppSight Application Problem Resolution System automates application problem resolution in the testing stage.
BMC AppSight Application Problem Resolution System
The BMC AppSight Application Problem Resolution System increases the output of development organizations by up to 40 percent by automating problem resolution processes during the development, testing, and support phases of the software lifecycle. BMC AppSight Application Problem Resolution System captures, communicates, and pinpoints the root cause of Microsoft Windows / .NET and J2EE application problems — from the user level down to the code.
BMC AppSight Application Problem Resolution System is the only solution that addresses all dimensions of the problem resolution process, integrating into all existing development, testing, and support processes, and handling all problem types, in all application tiers, on all major application servers.
Process Automation throughout the Application Lifecycle
BMC AppSight Application Problem Resolution System leverages a unique problem resolution architecture based on patented black box software technology.
The BMC AppSight Black Box software captures application execution — much like a black box flight recorder in an aircraft — and consolidates it into a complete, synchronized, and correlated record, allowing developers to replay, rather than recreate, any reported problems. As a result, you can eliminate up to 50 percent of the cycle time typically consumed by root cause analysis.
During testing, the BMC AppSight Black Boxes run in the background while functional, performance, and user acceptance testing is performed (either manually or automatically). When a problem is detected, the full problem information is automatically saved and attached to a defect report within the defect tracking system. Because the full application execution is captured, there is little need to document the defect and no room for misinterpretation of the events leading up to the error. Your developers can access the recorded information directly from the defect tracking system, open it in the BMC AppSight analysis views, and quickly determine its root cause.
During application maintenance, the BMC AppSight Black Boxes are deployed in the production environment on demand, when problems that require the development team’s attention are reported. Full problem data is communicated to the developers in a highly efficient, secure fashion. Developers investigate the problem using the system’s analysis views and determine root cause without spending time on recreating the production or end-user environment — and without going through unnecessary communication cycles.
Using Black Box Flight Recorder Technologies to Record Problem Data
Installation of the BMC AppSight Black Boxes is easy, and can be performed directly through the system’s console. One black box is required for each Windows machine to be recorded. The black box can also be deployed over the Web to capture problems that occur on a remote end-user desktop.
The BMC AppSight Black Box software operates with an extremely low and easily tuned performance impact, and does not require modifications to the application code or application server. Its settings, called “recording profiles,” may be changed at run-time to control the type and amount of data recorded.
BMC AppSight Black Boxes are either connected to a BMC AppSight Application Problem Resolution System Server, which provides centralized control, or run as stand-alone applications. Recordings are stored in a black box log file and can be automatically attached to a defect report or a trouble ticket for true process integration. The system is integrated with common defect tracking and service desk tools, and includes an open interface for custom integrations.
Getting Down to Root Cause
BMC AppSight Application Problem Resolution System automates the error-prone tasks of gathering information and documenting problems. The system frees developers from the need to recreate the problem environment (such as a test lab or a production environment) or reproduce the problem, and lets them proceed directly to analyzing the root cause. Supported Applications BMC AppSight Black Boxes BMC AppSight Analysis Views
Figure 2. BMC AppSight Application Problem Resolution System automates application problem resolution in the support stage.
The BMC AppSight analysis views enable developers to replay captured data at different levels, much like a DVD, and drill down to determine root cause. The views include three levels of analysis, which reflect the common root cause analysis workflow:
> User level — shows the end-user’s computer screen, keystrokes, and mouse clicks when the problem occurred.
> System level — provides information on system and application configuration, application performance, and a replay of all application events and operations, such as Web page execution, component invocations, database calls, and file access.
> Code level — replays application execution at the code level, displaying a tree of function calls, arguments, exceptions, and stacks. Works for all Microsoft .NET languages, C++, and Visual Basic.
Figure 3. A synchronized view of user-level and system-level activity eliminates the need to reproduce problems in a lab.
Common Problems with Windows / .NET applications
While Microsoft Windows / .NET addresses many of the issues historically associated with building and deploying distributed applications, it presents many new challenges related to deployment and support.
The following are some of the common problems associated with Windows / .NET applications:
Performance Problems
As with any software environment, performance problems are common and often difficult to pinpoint. The possible causes for these problems include:
> Inefficient code (e.g. frequent exceptions, many large objects, inefficient database calls — using ad hoc queries
rather than compiled stored procedures)
> Memory consumption (e.g. not freeing objects when they are no longer used, allocating too much memory per request, inadequate definition of maximum number of worker and IO threads)
> Improper application settings (e.g. inadequate session-state provider, buffering disabled on a Web forms page)
> Interoperability with legacy Windows code (e.g. assembling a lot of data from COM/COM+ to managed .NET objects)
> Infrastructure problems (e.g. bad network response times that cause degradation in application performance)
Figure 4. Your developers can replay application execution at the code-level for deep root cause analysis.
Functional Problems
The Microsoft .NET Framework has been designed to free the developer from dealing with various programming tasks, such as memory allocations and security. However, just like in any development platform, coding errors are still in abundance.
Some of the most common coding errors are: > Incorrect business logic (e.g. incorrect calculation of interest rate) > Thread deadlock situations > A severe error that leads to an application crash
Configuration Problems
While .NET promises to resolve “DLL-hell” issues, configuration problems are far from gone. The following detail some of the common configuration issues with Windows / .NET applications:
> Insufficient permissions to access a resource
(e.g. no permission to write to an application directory)
> Incompatible components (e.g. incorrect versions of assemblies or COM/COM+ objects)
> Incorrect application settings in Windows / .NET configuration files > Conflicts with other applications (e.g. an anti-virus tool that causes a Web application to restart intermittently)
User Errors
Windows / .NET applications are built to serve end users. As with any software application, users make mistakes. Some of these mistakes are resolved quickly, while some take days to figure out.
Finding the root cause of configuration problems
| Root cause | How BMC AppSight Application Problem Resolution System helps pinpoint root cause |
| Insufficient access permissions (e.g. application cannot write information to a directory) | The BMC AppSight Black Box records all accesses and attempted accesses of the application to any resource on the computer, enabling a developer to quickly identify the problematic resource and root cause. Additionally, users can compare configuration to pinpoint such issues. |
| Conflict with other applications (e.g. an anti-virus tool causes the Web application to restart and lose session data) | The BMC AppSight Black Box records all the interactions of the user’s application with any other applications, thus allowing the BMC AppSight Application Problem Resolution System user to quickly identify conflict situations. Furthermore, the BMC AppSight Black Box can record any third-party application to understand its impact on the user’s application. |
| Incorrect application settings (e.g. incorrect port settings for the application) | The BMC AppSight Black Box records all accesses to application configuration files (.NET Config class), therefore allowing the developer to track application settings and understand their impact on the application’s execution. Using the BMC AppSight Application Problem Resolution console, users can compare application configuration recorded on two computers for rapid identification of differences. Furthermore, the BMC AppSight Black Box can be configured to collect any configuration (or log) files and save them as part of the BMC AppSight Black Box log, thus providing all the data required to pinpoint any application configuration issue. |
| Problems with accessing external resources or services (e.g. a Web Service cannot be invoked) | The BMC AppSight Black Box records all the interactions of the user’s application with any external resource or service, thus allowing the BMC AppSight Application Problem Resolution System user to quickly pinpoint any access issues. For example, the BMC AppSight Black Box will show unsuccessful Web Services calls, .NET Remoting calls, or failures in accessing a database. |
| Incompatible components (e.g. an incorrect version of a third-party component used by the application) | The BMC AppSight Black Box records the interactions of the application with homegrown and third-party components, thus allowing the user to easily identify unsuccessful component invocations and calls. |
Finding the root cause of end-user errors
| Root cause | How BMC AppSight Application Problem Resolution System helps pinpoint root cause |
| Incorrect business logic (e.g. incorrect calculation of interest rate) | The BMC AppSight Black Box records the complete flow of managed and unmanaged code, including function calls, arguments, return values, variable values, and stack. It also captures handled and unhandled exceptions, which may indicate a code problem. The BMC AppSight Black Box does not require any change in the application, and runs against optimized, production applications. Additionally, the BMC AppSight Black Box can automatically record internal logging functions (.NET Trace class). The events are integrated into the BMC AppSight Black Box log, thereby dramatically enhancing the value of internal logging. |
| Hang (e.g. due to a thread deadlock situation or the application waiting for a response from an external resource, such as a database) | The BMC AppSight Black Box records the execution of multiple threads and processes at the code level, allowing a developer to easily find the root cause of hang situations. |
| Crash (e.g. due to an access violation with a COM object) | The BMC AppSight Black Box records at the code level and automatically captures a stack dump upon crash events, thus allowing a developer to quickly understand the root cause of crashes. |
BMC AppSight Application Problem Resolution System and Internal Application Logging
In addition to achieving tremendous efficiency gains by automating the problem resolution process, users can also realize significant cost reductions in development of internal logging mechanisms. These development efforts, which are taken solely for the purpose of problem resolution, may represent 10 to 30 percent of the total cost of the project. BMC AppSight Black Box software technology records production-ready
applications at the code level, using a configurable recording profile, thus eliminating the need to build and maintain internal loggers. Using BMC AppSight Application Problem Resolution System, developers are able to dedicate more time to building new functionality, rather than investing time in developing logging code, which adds no value to end users. If internal logging functions (i.e., .NET Trace class functions) exist, the BMC AppSight Black Box will automatically embed them into the recorded log, thus allowing developers to retain their investment in internal logging.
BMC as recently released a White Paper titled “Scalability and Remedy Action Request System” which discusses how BMC Remedy Action Request System (AR System) can scale within an enterprise environment and how, by combining additional hardware resources with some of the scaling features of BMC Remedy AR System, you can create a truly worldwide enterprise application. We at Peningo Systems recommend this White Paper to any Remedy Consultant that is involved in a Remedy Action Request System implementation. 