FREE MOBILE CLOUD
COMPUTING CONCEPTS - TRAINING_MODULES_WITH_TONS_OF_VIDEOS
Post by Paul Sanderson with Local Core IT Specialists and Network Builders, Los
Application Resource Measurement (ARM) is a simple application programming
interface (API) that applications and middleware use to pass information about transactions to management software.
An application calls ARM just before
a transaction starts and again just after it ends. An ARM agent receives the calls, measures the transaction, and provides
that data to a management system.
ARM is an open standard defined by the Open Group. IBM, Hewlett Packard, SAS and Siebel are a few of the companies
that support the ARM standard and have delivered ARM instrumentation in their software.
IBM has ARMed its middleware—including WebSphere
and DB2—which provides a wealth of information about transaction performance.
But this doesn't provide the level of insight into application components
that is necessary to perform root-cause analysis. To get a full picture of what is happening with an application system it
is necessary to insert ARM calls into each component of the application. For instance, to get true end-to-end transaction
tracing, particularly with a thick client, you need to ARM the client.
Until now, ARMing an application has required changing the source code, which is
not feasible in many cases and not desirable in others. This situation has prevented most organizations from taking advantage
of the many benefits of ARM.
ARM any application without changing source code Now you can inject ARM calls into applications
without modifying the source code. You do not need access to source code or to compiled code for C/C++ applications. You do
not need the cooperation of the software vendor—you can ARM any application.
The ARM instrumentation is injected using RootCause,
which allows you to insert ARM calls at runtime, as the application executes.
ARM instrumentation added with RootCause is more flexible than regular
ARM calls. You can insert, delete or change ARM calls easily, without making any changes to application files.
This makes it possible to prototype
ARM calls quickly and inexpensively. ARM calls can be inserted, tested, modified, load tested and finalized in a fraction
of the time it would normally take.
You can significantly reduce the time, risk and expense involved in adding ARM instrumentation when you take this