ARM and APM: Unified Performance Assurance
Key Points
- Assuring app performance requires both the application‑level insight of APM and the infrastructure‑level optimization of ARM, which together guarantee resources are available when needed.
- In the “it’s the node” scenario, an ARM system uses real‑time infrastructure and application metrics to automatically tune cloud resources, eliminating guesswork about where performance bottlenecks lie.
- In the “it’s the code” scenario, APM provides deep runtime diagnostics that help developers quickly identify and fix code‑related issues in development or production environments.
- Turbonomic Application Resource Management for IBM Cloud Paks pulls data from IBM Observability by Instana (or other APM tools like AppDynamics, Dynatrace, New Relic) to map end‑to‑end relationships from business applications down to containers, pods, and nodes—all without installing extra agents.
- By automating resource allocation decisions based on fine‑grained metrics such as transaction counts, CPU, and heap usage, the ARM/APM combo turns the usual “whodunnit” blame game into proactive performance assurance.
Sections
- Combining ARM and APM for Performance - The speaker explains how integrating Application Resource Management with Application Performance Monitoring ensures steady app performance by optimizing infrastructure resources (“it’s the node”) and providing detailed runtime diagnostics for code issues (“it’s the code”).
- Automating Resource Management Decisions - The speaker explains how Turbonomic’s data‑driven action recommendations—spanning non‑disruptive memory increases to potentially disruptive VM resource reductions—can be manually vetted, then fully automated to lower IT spend and prevent application performance issues, especially when paired with Instana’s real‑time microservice metrics.
- Integrating APM with ARM - The speaker explains how combining Turbonomic's Application Resource Management with Instana's APM automates performance decisions, prevents issues before they arise, and reduces IT spend.
Full Transcript
# ARM and APM: Unified Performance Assurance **Source:** [https://www.youtube.com/watch?v=C9Sm0pmQLC0](https://www.youtube.com/watch?v=C9Sm0pmQLC0) **Duration:** 00:06:59 ## Summary - Assuring app performance requires both the application‑level insight of APM and the infrastructure‑level optimization of ARM, which together guarantee resources are available when needed. - In the “it’s the node” scenario, an ARM system uses real‑time infrastructure and application metrics to automatically tune cloud resources, eliminating guesswork about where performance bottlenecks lie. - In the “it’s the code” scenario, APM provides deep runtime diagnostics that help developers quickly identify and fix code‑related issues in development or production environments. - Turbonomic Application Resource Management for IBM Cloud Paks pulls data from IBM Observability by Instana (or other APM tools like AppDynamics, Dynatrace, New Relic) to map end‑to‑end relationships from business applications down to containers, pods, and nodes—all without installing extra agents. - By automating resource allocation decisions based on fine‑grained metrics such as transaction counts, CPU, and heap usage, the ARM/APM combo turns the usual “whodunnit” blame game into proactive performance assurance. ## Sections - [00:00:00](https://www.youtube.com/watch?v=C9Sm0pmQLC0&t=0s) **Combining ARM and APM for Performance** - The speaker explains how integrating Application Resource Management with Application Performance Monitoring ensures steady app performance by optimizing infrastructure resources (“it’s the node”) and providing detailed runtime diagnostics for code issues (“it’s the code”). - [00:03:04](https://www.youtube.com/watch?v=C9Sm0pmQLC0&t=184s) **Automating Resource Management Decisions** - The speaker explains how Turbonomic’s data‑driven action recommendations—spanning non‑disruptive memory increases to potentially disruptive VM resource reductions—can be manually vetted, then fully automated to lower IT spend and prevent application performance issues, especially when paired with Instana’s real‑time microservice metrics. - [00:06:09](https://www.youtube.com/watch?v=C9Sm0pmQLC0&t=369s) **Integrating APM with ARM** - The speaker explains how combining Turbonomic's Application Resource Management with Instana's APM automates performance decisions, prevents issues before they arise, and reduces IT spend. ## Full Transcript
You likely monitor app performance,
but what do you do to assure app performance?
And when users report their app is slow,
what do you do?
Hi, I'm Dan Kehn from IBM Cloud.
In this video, I'll explain why platforms
for Application Resource Management, or ARM,
and Application Performance Monitoring, or APM,
can work together
to solve some particularly knotty performance problems
for your business applications.
So how do you assure app performance?
In principle, it's simple--
you need to make sure the applications
have the resources they need, when they need them.
This is where the goals of APM and ARM systems intersect.
You can get steady, predictable performance
by combining the application level
understanding of an APM
with the infrastructure know-how of an ARM.
To explain how ARM and APM systems work,
I'll walk through two scenarios.
The first I call "it's the node",
Instead of relying on educated guesses,
I'll show how an ARM system
can use infrastructure and application metrics
to optimize cloud resources for performance.
The second I call "it's the code".
As a developer, I know that better runtime diagnostics
will make my job easier.
I'll show an APM system can help debug tricky problems,
whether it's in your dev or production environment.
Let's get to it.
I referred to this first scenario
as the "it's the node" view of performance
because today's modern business applications
run in containers,
which are hosted by virtual machines
that are on-premise or in the public cloud.
But that's the infrastructure's view of the world.
Your customers think in terms what the application does,
not how it executes.
Once deployed to select environments,
Turbonomic Application Resource Management
for IBM Cloud® Paks uses the data from standard APM API
to discover both application and cloud entities.
It then builds this end to end supply chain view
from top level business application
down to the supporting infrastructure.
These diagram relationships act as a single source of truth
for application performance in your hybrid environment.
In this case, Turbonomic is pulling in analytics data
from IBM Observability by Instana APM.
But it can also work with APM tools
like AppDynamics, Dynatrace, and New Relic.
No agents are required to be installed.
With the help of this data,
it recognizes their associated transactions,
services, and application components,
as well as the infrastructure components
like containers, pods, and nodes.
Okay, let's return to my opening question.
When the user reports their applications is slow,
what happens next?
Whether it's a war room or a group chat, I'll bet
your approach boils down to creating a whodunnit list
of suspected services and infrastructure components.
How do we change this blame game?
By automating resource allocation decisions
based on data like application transactions
and application CPU, or application heap.
Not just large grain metrics like container RAM usage.
That's the secret sauce of ARM/APM combo.
It can avoid the mistake
of incorrectly estimating resource requirements
that lead to performance problems.
The Turbonomic proposed actions shown here
are fundamental ARM decisions
independent of the underlying technology.
Yikes! That's a lot of actions.
There's actions for decreasing node memory,
reallocating VM resources, and tweaking the permitted IOPS.
But don't worry, lots of actions are a good thing.
Sure, until you trust the recommendations,
you'll go through them manually,
but long-term you let the system handle them automatically.
In other words,
the performance objective is decision automation
for resource management, not just process automation.
These actions can help you reduce your IT spend.
And since the actions are based on usage data,
you'll get more recommendations over time.
You begin by reviewing the actions you should take.
This view provides context,
like whether it's a non-disruptive action,
such as increasing memory, or potentially disruptive,
like reducing the resources of a VM.
Once you validate enough proposed actions
and you are confident the recommendations are trustworthy,
you can move to the next stage: decision automation.
That's the end game--
eliminating resource problems
as a source of application delay
so your users don't need to call you
about performance problems in the first place.
Okay, in the prior scenario,
Turbonomic plus Instana
helped intelligently manage resources
based on actual runtime metrics.
It took advantage of microservice metrics
captured by Instana like load, latency,
error rate, and saturation.
That can lead to better performance and reduce IT costs.
As a bonus,
you can escape the resource management blame game,
but for diagnosing actual performance problems
at the code level,
Instana's always-on tracing
can really save debug time.
Let's take a quick look at the "it's the code" scenario.
Based on a chat message from Cloud Pak® for Watson AIOps,
you can proactively investigate and resolve brewing issues
before they impact users.
Combined with the deep dive performance monitoring tools
from Instana, you can confirm the details
that led to an incident report.
In this case, a sudden increase
in the error returned by the discount service.
The event that triggered the incident
shows that the error rates spike suddenly.
This unexpected behavior is automatically detected by Instana
without the need to manually set and maintain thresholds.
As shown in the related events,
the abnormal termination of the MySQL process
was the root cause.
Once the database was brought back online,
the discount service returned to normal operation.
Let's review the trace logs that pointed the cause.
Here we see that the failing calls
to the discount service took about two seconds,
suggesting a timeout situation.
We can confirm this in the trace detail.
It shows how the error in the timeline,
indicated by the red triangle, propagated up the call stack,
ultimately returning to server 500 error.
If needed, the ops team and dev team
have access to more low-level detail,
such as the call stack, application components stack,
log details, even previews of the underlying source code.
Now you see as a developer,
why I'm excited about how Instana
helps diagnose and resolve difficult code problems,
even in a production environment.
Okay, let's summarize.
By integrating APM and ARM,
the ARM system can automate decisions
informed by application metrics
as well as infrastructure awareness.
That's why the combination of Turbonomic and Instana
helps you take full advantage
of the performance elasticity of cloud platforms
without over-provisioning.
What could this mean to your company?
ARM automation can address performance problems
before they occur and reduce IT spend.
This means more time and money
to put towards expanding your business
rather than reacting to alerts and trouble tickets.
Thanks for watching.
If you'd like to see more videos like this in the future,
please click like and subscribe.
If you want to learn more
about Turbonomic Application Resource Management
for IBM Cloud Paks and IBM Observability by Instana APM,
please make sure to check out the links in the description.