Abstract: Embodiments of the present invention provide a method for monitoring components in a library by tracking the movement of library components. By tracking the movement of library components, the degradation of library components can be monitored and the reliability of library components determined, allowing unreliable components to be bypassed or replaced, enhancing the reliability of the library and preventing data loss.

Abstract: A system, method and computer program product for verifying integrity of a running application program on a computing device. The method comprises: determining entry points into an application programs processing space that impact proper execution impact program integrity; mapping data elements reachable from the determined entry points into a memory space of a host system where the application to verify is running; run-time monitoring, in the memory space, potential modification of the data elements in a manner potentially breaching program integrity; and initiating a response to the potential modification. The run-time monitoring detects when a data transaction, e.g., a write event, reaches a malicious agent's entry point, a corresponding memory hook is triggered and control is passed to a security agent running outside the monitored system.

Abstract: Systems and methods for real time performance monitoring of an application are described. In one implementation, when a metrics collection request is obtained from a user device, a data storage location is selected from a plurality of data storage locations based on a location status associated with the data storage location. The metrics data, for monitoring the performance of the application, is then provided to the user device through a data store from the selected data storage location in real time.

Abstract: A computer implemented method, apparatus, and computer usable program code for returning a return code to an error hook in an application using a framework. An identifier and a pass-through are received from the error hook. The error hook is software code in the application. The pass-through is a set of parameters. If the identifier has an active status, a set of framework conditions is retrieved using the identifier. If the set of framework conditions is met, an inject callback is retrieved using the error identifier. The inject callback is called with the error identifier and the pass-through. An inject callback return code is received. If the inject callback return code is an execute return code, the execute return code is returned to the error hook.

Abstract: A method, computer program product, and system for transforming unit tests is described. A unit test associated with one or more software units is identified. A first input parameter of the unit test is identified. A substitute parameter value is determined, wherein the substitute parameter value is associated with a security test for the one or more software units. A value of the first input parameter in the unit test is replaced with the substitute parameter value. The unit test including the substitute parameter value is implemented for the one or more software units. A first security issue associated with the one or more software units is identified, based upon, at least in part, replacing the first input parameter of the unit test with the substitute parameter value and implementing the unit test including the substitute parameter value.

Abstract: Systems and methods for generating profiling data include monitoring the execution of a task on a thread of a program. Profiling data may be generated that includes metrics regarding the execution of the task. A profiling data aggregation service may aggregate generated profiling data from a plurality of devices that execute the program.

Abstract: The present invention provides a system, computer program product and a computer implemented method for prioritizing code fragments based on the use of a software oracle and on a correlation between the executed code fragments and the output they produce. Also described is a computer-implemented method generates additional user inputs based on execution information associated with path constraints and based on information from the oracle. Advantageously, the embodiment is useful in a test generation tool that generated many similar inputs when a failure-inducing input is found, in order to enhance fault localization. Further, described is a computer-implemented flow for extending the existing idea of concolic testing to applications that interact with persistent state.

Abstract: Systems, methods and articles of manufacture to in-line script dependencies are discussed herein. An embodiment includes extracting test resources addressed in language defining a test web page, placing markers identifying the location of each extracted test resource within the language defining the test page, iteratively loading external resources associated with a path of each test resource, analyzing each test resource to identify one or more dynamically added dependencies, and replacing each marker with external resources and dependencies that reference their respective marker to generate updated language defining an updated test web page. The embodiment further includes adding each identified dependency after or before a top level parent resource, performing the analyzing and the adding until no new dependencies are identified and providing each new dependency with a reference to a parent marker associated with the top level parent resource.

Abstract: A method, computer-readable storage medium, and computer system are provided. In an embodiment, in response to a command that requests setting a breakpoint at a line in a module, a determination is made whether a snapshot instruction exists before a machine instruction that implements a source statement at the line. If the snapshot instruction exists before the machine instruction that implements the source statement at the line, the breakpoint is set at the machine instruction that implements the source statement at the line. If the snapshot instruction does not exist before the machine instruction that implements the source statement at the line, the module is recompiled to add the snapshot instruction before the machine instruction that implements the source statement.

Abstract: Techniques for monitoring web application performance are provided. A request for a web application is received at an application server. A response pipeline at the application server generates client application code corresponding to the requested web application. The client application code is intercepted in the response pipeline. Instrumentation code is inserted into the intercepted client application code to generate an instrumented client application code. The instrumentation code is configured to be executed when the instrumented client application code is rendered at the client to capture performance information at the client, and is configured to transmit the captured performance information from the client.

Abstract: The present technology may determine an anomaly in a portion of a distributed business application. Data can automatically be captured and analyzed for the portion of the application associated with the anomaly. By automatically capturing data for just the portion associated with the anomaly, the present technology reduces the resource and time requirements associated with other code-based solutions for monitoring transactions. A distributed business application is monitored to detect an anomaly based the learned behavior of the business application. The behavior may be learned for each of one or more machines which implement a distributed business transaction. The present system may automatically collect diagnostic data for one or more business transactions and/or requests based on learned behavior for the business transaction or request.

Abstract: Systems and methods for test data generation are described. In one implementation, the method includes receiving seed data having one or more characteristics. Further, the method includes obtaining a selection criterion indicating a selected portion of the seed data to be transformed. Based on the selection criterion, the seed data is transformed for at least a plurality of iterations to generate test data. The test data comprise a plurality of data sets including a primary data set generated in a first iteration and a secondary data set generated in each subsequent iteration. The primary data set includes transformed data corresponding to the selected portion of the seed data and non-transformed data corresponding to a remaining portion of the seed data and each secondary data set includes transformed data corresponding to the selected portion of the seed data.

Abstract: The present technology monitors a web application provided by one or more services. A service may be provided by applications. The monitoring system provides end-to-end business transaction visibility, identifies performance issues quickly and has dynamical scaling capability across monitored systems including cloud systems, virtual systems and physical infrastructures. A first parameter may be received from a first computer by a server. A second parameter may be received from a second computer by the server. A distributed application processed on the first computer and the second computer may be correlated based on the first parameter and the second parameter.

Abstract: Described is a probabilistic concurrency testing mechanism for testing a concurrent software program that provides a probabilistic guarantee of finding any concurrent software bug at or below a bug depth (that corresponds to a complexity level for finding the bug). A scheduler/algorithm inserts priority lowering points into the code and runs the highest priority thread based upon initially randomly distributed priorities. When that thread reaches a priority lowering point, its priority is lowered to a value associated (e.g., by random distribution) with that priority lowering point, whereby a different thread now has the currently highest priority. That thread is run until its priority is similarly lowered, and so on, whereby all schedules needed to find a concurrency bug are run.

Abstract: In a system and a method, a sub-test catalog is retrieved from a test catalog repository. A test aspect of the sub-test catalog is compared to an aspect of a software application to be tested. A required system capability of the sub-test catalog is compared to the capabilities of a system landscape based on a determination that the sub-test catalog test aspect matches the aspect of the software application to be tested. The system landscape includes at least one system. The sub-test catalog is added to a master test catalog based on a determination that the required system capability of the sub-test catalog matches the system landscape capabilities.

Abstract: Exemplary embodiments enable debugging executable code using a debugger in a computational device that provides a programming environment including a presentation layer. For example, an exemplary method includes providing a first marshalling function that receives a portion of information manipulated by the executable code and produces a presentation layer representation of the portion of the information. The presentation layer representation is compatible with a debugger that debugs the executable code. An exemplary method also includes debugging the executable code to produce a presentation layer representation of the portion of the information with the first marshalling function so as to display the presentation layer representation of the portion of the information to a user via a display device. The debugging also includes modifying the presentation layer representation of the portion of the information to produce modified information for use by the executable code, a device, or a user.

Abstract: A method for verifying an input/output (I/O) hardware configuration is provided. Data from an input/output data set (IOCDS) is extracted for building a verification command. The IOCDS contains hardware requirements that define at least software devices associated with a logical control unit (LCU). The verification command is processed. The verification command includes a software device address range associated with a logical control unit (LCU) of the I/O hardware. The LCU utilizes a first logical path. The software device address range utilizing the first logical path is compared with an existing software device address range utilizing at least one additional logical path. The verification command is accepted if the software device address range and the existing software device address range match.

Abstract: Displaying instrument output is disclosed. Instrument output data is received. A difference between two or more corresponding portions of data included in the received instrument output data is determined. At least a selected part of the received instrument output data is displayed in a manner that highlights the difference.

Abstract: Identify a first change to a first portion of the system, and identifying at least a second portion of the system that is, at least in part, dependent on the first portion. At least one user who is assigned responsibility for maintaining the first portion or the second portion of the system can be identified, and an availability of the user to maintain the first portion or the second portion of the system during a time period can be determined. The time period can begin when the first change is initially scheduled for introduction into the system. Responsive to determining that the user is not sufficiently available to maintain the first portion or the second portion of the system during the time period, the first change can be prevented from being introduced into the system as initially scheduled for introduction into the system.

Abstract: An information processing system, computer readable storage medium, and method for documenting the execution of long running applications. A processor of the information processing system operates to continuously collect snapshots monitored from an executing application on a runtime system. The processor selects, based at least on user specified policies, collected snapshots that indicate a significant change in runtime behavior of the executing application on the runtime system. The processor annotates each of the selected snapshots with description of the significant change in runtime behavior of the executing application. The processor operates to store and update documentation of an execution history of the executing application from the annotated snapshots.

Abstract: Tracer objectives in a distributed tracing system may be compared to identify input parameters that may have a high statistical relevancy. An iterative process may traverse multiple input objects by comparing results of multiple tracer objectives and scoring possible input objects as being possibly statistically relevant. With each iteration, statistically irrelevant input objects may be discarded from a tracer objective and other potentially relevant objects may be added. The iterative process may converge on a set of statistically relevant input objects for a given measured value without a priori knowledge of an application being traced.

Abstract: Techniques are provided for determining dependencies in a mainframe development environment. While executing a first build file to generate a first build of a software program from files in a file system, the activity in the file system is monitored to determine a plurality of files that are being accessed, and first information about the plurality of files is recorded. The first information is sent to a configuration management server. From the configuration management server, second information is received that indicates one or more dependencies which are determined among the plurality of files based on the first information. Based at least on the second information, a second build file is generated. The second build file is executed to generate a second build of the software program, where the second build is generated more efficiently by using less computing resources than the first build of the software program.

Abstract: Method, system and computer program product for performing an operation, the operation including providing a plurality of processing elements comprising one or more operators, the operators configured to process streaming data tuples. The operation then establishes an operator graph of multiple operators, the operator graph defining at least one execution path in which a first operator of the plurality of operators is configured to receive data tuples from at least one upstream operator and transmit data tuples to at least one downstream operator. The operation then defines a breakpoint, the breakpoint comprising a condition, the condition based on attribute values of data tuples in a window of at least one operator, the window comprising a plurality of data tuples in an operator. The operation, upon detecting occurrence of the condition, triggers the breakpoint to halt processing by each of the plurality of operators in the operator graph.

Abstract: Method product for performing an operation, the operation including providing a plurality of processing elements comprising one or more operators, the operators configured to process streaming data tuples. The operation then establishes an operator graph of multiple operators, the operator graph defining at least one execution path in which a first operator of the plurality of operators is configured to receive data tuples from at least one upstream operator and transmit data tuples to at least one downstream operator. The operation then defines a breakpoint, the breakpoint comprising a condition, the condition based on attribute values of data tuples in a window of at least one operator, the window comprising a plurality of data tuples in an operator. The operation, upon detecting occurrence of the condition, triggers the breakpoint to halt processing by each of the plurality of operators in the operator graph.

Abstract: Disclosed in some examples are systems, machine readable mediums and methods which automate testing of web-based application code by automatically generating test harnesses based on a specified configuration and test script, hosting the test harness, causing the test harness to be run to test the code, and delivering the test results to the user. In some examples, the specified conditions may specify one or more test environments corresponding to an execution environment. This allows users greater flexibility in support of testing libraries and support of testing environments. The end users of the software under test will be provided software that is better tested for many different environments.

Abstract: Identifying a code segment that has a likelihood of causing a program failure. Program code is executed to a failure point. A plurality of code segments executed in the program code prior to the failure point are identified. Changesets that contain at least one of the identified code segments are identified. The identified code segments are then ranked as a function of likelihood that each respectively ranked identified code segment caused the failure point, based, at least in part, on the identified changesets. In another aspect of the invention, at least some of the ranked code segments along with an indication of the ranking are reported.

Abstract: Methods and systems for providing a monitoring center with sensors that are inserted at one or more locations within an operating framework software engine. The sensors monitor the interpretive framework engine's process of loading commands, combining variables with coded commands, and executing commands with event processing, variable values, and user interactions. The sensors watch and gather information that has been deemed relevant by the monitoring center's configuration and pass that information to the center so that storage functions can route the information to the appropriate data storage locations. Alternatively, each sensor can be self-contained providing monitoring, gathering, processing, data transmission, and storage within the sensor.

Abstract: A product deployment system of an electronic document is described. An example product deployment system includes a deployment processor, a remote execution module, and a plan manager. The deployment processor may be configured to receive a request to deploy an application, generated a deployment plan, provide the deployment plan to the plan manager, and trigger a command to be sent from the remote execution module to the target hosts in the target host set. The plan manager provides the deployment plan to the target host set in response to receiving the identification of the deployment plan from the target host set. The plan manager may also monitor execution of the deployment plan by the target host set without saving a state of deployment process that is being performed at the target host set. The plan manager may also react to perceived failures that may occur at the target host set.

Abstract: A method and system debug a computer program by using trace data, which is a recording of the sequence of machine instructions executed by a program during a time period along with the addresses and values of memory locations accessed and modified by each machine instruction. After the time period, the method and system use the trace data to simulate the execution of the program during the time period under the control of a debugger. In addition, the method and system use the trace data to simulate the execution of the program during the time period backwards in time under the control of the debugger.

Abstract: A dual-mode debugger can debug native code or interpreted code. Transitioning between modes can be triggered by defined bailout conditions. A program can be debugged by attaching a debugger and compiling the program into native code under the debugger. At defined points in the program, debugging can transition from native mode to interpreted mode. Debugging the native code can stop, current state can be captured, and an interpreter can be instantiated. An interpreter stack can be created and can be populated with the captured current state. Debugging operations which involve execution control: pausing execution, continuing execution, stepping into, out of or over a section of code and so on, can occur in interpreted mode, which is typically easier to implement. Debugging operations which involve inspection and modification of variables can occur in native mode.

Abstract: An apparatus and method for aiding in debugging and optimizing software is presented, in particular for instrumenting software to trace function calls. Source code is compiled with placeholder memory ranges. While executing the compiled binary object, a call-trace profiling function is inserted into at least certain of the placeholder memory ranges to log call-trace profiling data. Then, the compiled binary object is restored to its original state by removing the call-trace profiling function(s). A NOP function can be inserted in each placeholder memory range during compilation.

Abstract: Software debugging recommendation technique embodiments are presented that generally entails creating a database of characterized software bug descriptions and providing software debugging recommendations from the database in response to a query. This can employ a two-phased approach in the search for similar software bugs. The first is a search phase that takes a query as input and returns a ranked list of software bug descriptions that match the query. These bug descriptions can contain a mix of structured and unstructured data. The second phase is a related-information phase that uses the output of the first phase to retrieve a set of related recommendations such as for people, source files, functions and binaries.

Abstract: A method for packaging an application, for use with a system comprising the application and a plurality of libraries, the method comprising: in response to runtime execution of the application, monitoring library data associated with at least one of the plurality of libraries that is invoked by the application; associating the library data with an identifier of the application; and using the library data and the application identifier to create a package comprising the application and the at least one of the plurality of libraries.

Abstract: An installation comprises at least one sensor for providing sensor data representing a real system state of the installation and at least one actuator for acting on the real system state. A controller for controlling the installation comprises a data memory for storing the sensor data and a program memory for storing a machine code program. A programming tool for programming the controller includes a program editor, a debugging tool and a compiler. A machine code program is executed on the controller while the debugging tool is activated, and the debugging tool determines a reverse relationship between the machine code running on the controller and at least one high level control instruction shown in the program editor, thereby linking at least one high level control instruction to a real system state during the execution of the machine code program.

Abstract: A computer-implemented method is provided for determining the performance of an application platform. The application platform includes one or more applications associated with a plurality of resources of a computer system. A plurality of synthetic resource consumers are disposed within the application platform. Each synthetic resource consumer is configured to consume at least one of the plurality of resources. A workload profile is provided to the plurality of synthetic resource consumers. The workload profile includes parameters specifying resource consumption by the plurality of synthetic resource consumers. Performance data is acquired based on the impact of the workload profile on the plurality of resources and the plurality of applications.

Abstract: The present disclosure is directed to a method and system for bulk-loading data into a data storage model. In accordance with a particular embodiment of the present disclosure a script having a plurality of statements is executed. Executing the script includes executing the plurality of statements in a predetermined order. One or more failed statements are identified. Each of the one or more failed statements are re-executed according to the predetermined order.

Abstract: A method, system, and computer usable program product for on-demand monitoring of memory usage are provided in the illustrative embodiments. An indication of a memory leak in an application is detected where the application is operating in a data processing system and using a memory associated with the data processing system. An instruction to begin monitoring a memory usage of the application is received responsive to the detection. Responsive to receiving the instruction to begin, the memory usage of the application is monitored. An instruction to dump a data related to the monitoring is received and the data is dumped. An instruction to end the monitoring is received and the monitoring is ended. The detecting, the beginning, the dumping, and the ending may occur while the application remains in operation and while the application uses the memory. The memory leak is confirmed using the data.

Abstract: A mechanism is provided for collecting one or more performance metrics. A plurality of source code instructions is provided. The source code instructions include a plurality of macro calls. Each of the plurality of macro calls includes a plurality of predetermined parameters. A plurality of object code instructions corresponding to the plurality of source code instructions is executed. In response to receiving a signal identifying at least one of the plurality of macro calls contained in the source code instructions and identifying a desired level of granularity, performance metrics are collected using the identified macro call in accordance with the desired level of granularity.

Abstract: A machine vision system editing environment is provided for a part program in which a continuous stream of image acquisition operations are performed during a run mode. In one embodiment, a new common syntax and representations are utilized wherein continuous image acquisition operations are recorded in the same way as regular operations, with the running of the part program being performed in two stages. In the first stage, the portion of the part program that is to have the continuous stream of image acquisition is scanned for image acquisition operations, and the most efficient order for acquiring the images is determined, after which the image acquisition process is begun. Then, in the second stage, while the image acquisition process is being performed, the portion of the part program is scanned again, with the image analysis operations then being performed.

Abstract: A computer identifies a target for an injection of an error. The computer monitors the call graph, of a program being tested, for instances of the target. The computer identifies an instance of the target in the call graph. The computer determines if the instance of the target satisfies two or more parameters required for error injection. If the computer determines that the instance of the target does satisfy two or more parameters required for error injection, then the computer injects a first instance of an error into a leaf function of the call graph. The execution of the first instance of the injected error results in a first code path, of the program being tested, to be followed.

Abstract: A computer-implemented system for managing software problem reports includes a registration sub-system to register software developers from multiple different developer organizations; an application store that makes a plurality of applications from a plurality of application developers available for acquisition by members of the public; an application bug tracker programmed to receive reports of problems with applications distributed using the application store, to receive data regarding the problems, and to associate the data with a particular application or developer of the particular application; and a report generator to produce one or more problem reports for a developer that has provided one or more applications, the problem reports including information about the data regarding the problems relating to particular applications submitted to the application store by the developer.

Abstract: The invention efficiently provides user code information for kernel level tracing approaches. It applies an advanced variation of stack walking called multi-mode stack walking to the entire system level and generates the unified trace where the user code and kernel events are integrated. The invention uses runtime stack information and internal kernel data structures. Therefore, source code for user level code and libraries are not required for inspection. The invention introduces the mechanism to narrow down the monitoring focus to specific application software and improve monitoring performance.

Abstract: A computer collects first test metrics on a transaction hosted within a middleware container, and is executing within a first environment. The computer generates baseline values of expected execution behavior of the transaction based on the first test metrics. The computer collects second test metrics on the transaction hosted within the middleware container, and is executing within a second environment. The computer compares the second test metrics to the baseline values. The computer determines whether the second test metrics satisfy the baseline values. In response to the second test metrics not satisfying the baseline values, the computer identifies the transaction as a candidate for cancellation.

Abstract: Embodiments are directed to handling errors in a distributed software application. In one scenario, a computer system instantiates a distributed application which is configured for execution on multiple different computer systems. The computer system determines that an exception has occurred during the execution of the distributed application on at least one of the computer systems and translates the exception that occurred during distributed execution in a distributed environment into a serial exception that appears to have occurred during serial execution in a serial execution environment. The computer system then presents the translated serial exception to an application developer or other user.

Abstract: A method for implementing a step over operation by a debugger for an instruction in a routine includes receiving a step over command for an instruction and determining whether the instruction is a branch used for a function call. If the instruction is not a branch used for a function call, then the debugger treats the instruction as not a function call. If the instruction is a branch used for a function call, then the debugger determines whether the instruction is generated from source code. If the instruction is not generated from source code, then the debugger treats the instruction as not a function call. If the instruction is generated from source code, then the debugger treats the instruction as a function call.

Abstract: Methods and apparatuses enable fast business process test case composition. Instead of the labor intensive and error-prone manual test case composition of previous systems, a group of one or more test agents enables creation of a business process test based on monitoring a business process application. The test agents monitor a backend interface of the business process application that interfaces the application with a backend enterprise system. The test agents generate business process test components and an ordering for the business process test components based on the monitoring. From the test components and the monitoring, the test agents create a business process test. The entire creation process can be performed with little to no user interaction.

Abstract: In application testing and debugging processes, it is necessary to change, rebuild and test code. Thus, to speed the testing and debugging process, the process of retrieving application change lists, rebuilding the application, executing the application and recording application performance metrics may be automated. Additionally, through the use of environment independent metrics 110, application performance can be better evaluated for a wider range of hypothetical hardware configurations than tradition metrics which are highly dependent on the environment in which the test is running.

Abstract: A method and apparatus to record one or more customization messages in a storage are described. Each customization message may include one or more predicates specifying applicability of the customization message for a plurality of objects. An operation on the objects may be performed to generate a configuration of a device in response to receiving an event. The configuration may include the objects. Each customization message may be selectively applied to the objects in the configuration to customize the configuration. An object may be updated via the customization message if the predicates match the object in the configuration. The device may be configured via the customized configuration.

Abstract: A computer implemented method and system including techniques for developing and executing automated test cases are described herein. In one embodiment, a test case automation tool provides functionality for defining an automated test set and associated test cases within a testing user interface without the use of scripting languages or compiled programming. The definition of each test case may occur within a testing user interface, including displaying and receiving user selection of available methods for testing; displaying user parameter fields and receiving user parameter values in response for testing; abstracting parameter types in the user parameter values; and generating XML-format definitions of the test case. The test case automation tool may then execute the selected methods of the software application using parameters provided in the XML-format definitions, and return testing results of the test case execution.

Abstract: Stepping out of an asynchronous process. A method includes, as part of a computer program execution, at a caller, making an asynchronous function call from the caller to a callee. Associated with the asynchronous function call a continuation waits for the completion of the callee with respect to the asynchronous function call. The method further includes correlating a debugging indicator to the callee indicating that a user wishes to step out of the caller when the callee returns. An indication of completion of the callee with respect to the asynchronous function call and that a user wishes to step from the callee to the continuation is received. The debugging indicator is referenced and based on the debugging indicator execution at entry into the continuation is stopped.