Related pages: |
After you understand the basics of , you can learn how
models application environments. The model serves as the framework around which
organizes and presents performance information.
A typical application environment consists of different components that interact in a variety of ways to fulfill requests from the application's users:
app agents automatically discover the most common application frameworks and services. Using built-in application detection and configuration settings, agents collect application data and metrics to build flow maps.
A flow map visually represents the components of your application to help you understand how data flows among the application components. For example, the business transaction flow map for a simple e-commerce application shows data flowing between web services, message queues, and databases:
Automatic detection lets you start exploring features quickly. As your understanding of
matures and you identify areas unique to your environment, you can refine your application model.
In the model, a business transaction represents the data processing flow for a request, most often a user request. In real-world terms, many different components in your application may interact to provide services to fulfill the following types of requests:
app agents discover requests to your application as entry points to a business transaction. Similar requests, such as user login, are treated as multiple instances of the same business transaction. The agents tag the request data and trace the request path as it passes from web servers to databases and other infrastructure components.
collects performance metrics for each tier that processes the business transaction.
Because orients performance monitoring around business transactions, you can focus on the performance of your application components from the user perspective. You can quickly identify whether a component is readily available or if it is having performance issues. For instance, you can check whether users able to log in, check out or view their data. You can see response times for users, and the causes of problems when they occur.
A business application is the top-level container in the model. A business application contains a set of related services and business transactions.
In a small deployment, only a single business application may be needed to model the environment. In larger deployments, you may choose to divide the model of the environment into several business applications.
The best way to organize business applications for you depends on your environment. A leading consideration for most cases, however, is to organize business applications in a way that reflects work teams in your organization, since role-based access controls in the Controller UI are oriented by business application.
A node in the model corresponds to a monitored server or JVM in the application environment. A node is the smallest unit of the modeled environment. Depending on the agent type, a node may correspond to an individual application server, JVM, CLR, PHP application, or Apache Web server.
Each node identifies itself in the model. When you configure the agent, you specify the name of the node, tier, and business application under which the agent reports data to the Controller.
A tier is a unit in the model composed of a grouping of one or more nodes. How you organize tiers depends on the conceptual model of your environment.
Often a tier is used to a group of a set of identical, redundant servers. But that is not strictly required. You can group any set of nodes, identical or not, for which you want performance metrics to be treated as a unit into a single tier.
The single restriction is that all nodes in a single tier must be the same type. That is, a tier cannot have mixed types of agents, such as both .NET and Java nodes.
The traffic in a business application flows between tiers, as indicated by lines on the flow map, which are annotated with performance metrics.
In the model:
An entity is any object that monitors, such as an application, tier, node, or even a business transaction. Entities typically have associated metrics, events, and a health status.
Tags are key-value pairs that are associated with your entities, such as applications, tiers, nodes, synthetic pages, and servers. These tags act as metadata that help you find your application resources in the Controller UI. You can reduce the Mean Time To Detection (MTTD) of any entity related issues by tagging them using appropriate custom tags.
You import the custom tags from CMDB (using a sync utility) or API source using the Custom Tagging API. You view the custom tags in the right pane of the Application dashboard and Tiers & Nodes dashboard.
To filter the entities using the custom tags, navigate to the entity page, then click Tag Filter and select the tags from the list. A list of entities that matches the selected tag filter criteria displays.
For example, if you want to find entities by their owner name, you can use the owner tag within the Tag Filter to view entities that match the selected owner tag. Tags help you to narrow the entity selection.
The following are the default tag permissions for the default roles. You can create custom roles and assign custom tag permissions.
| User Role | Default Tag Permissions |
|---|---|
Server Monitoring Viewer | View tags on Servers but not on Applications and related entities |
| Server Monitoring Administrator | View and edit tags on Servers but not on Applications and related entities |
| Account Owner | View and edit tags on Applications (and related entities) and Servers |
| Administrator | View and edit tags on Applications (and related entities) and Servers |
| Database Monitoring User | Cannot view or edit tags |
| App and Dashboard Viewer | View and edit tags on Applications (and related entities) but not on Servers |
| Dashboard Viewer | Cannot view or edit tags |
| Analytics Administrator | View and edit tags on Applications (and related entities) but not on Servers |
| Universal and Workflow Roles | Cannot view or edit tags |
You can create custom roles and assign custom tag permissions. See VIEW_TAGS and MANAGE_TAGS permissions in Role Permissions for Entity Actions.
To filter the entities, perform the following:
The Controller has an entity liveness module that tracks the "live" or "historical" status of the the four entity types: application, tier, node, and business transaction for 365+ days.
The entities have special metrics called anchor metrics that are used to determine the liveness of the entity. This table lists the anchor metrics for each of the entities.
Entity | Anchor Metric |
|---|---|
| Application | Agent | App | Availability |
| Tier | Agent | App | Availability |
| Node | Agent | App | Availability |
| Business Transactions (BTs) | BTM | BTs | BT: %d | Component: %d | Calls per Minute |
The liveness of an entity affects the associated entities as the liveness is rolled up the hierarchy. If the entity type in the table is live, you can determine the liveness of the associated entities in the right column.
Live Entity | Liveness Status |
|---|---|
| Application | An app is alive if any tiers in this app are alive |
| Tier | A tier is alive if any nodes in this tier are alive |
| Node | Any metrics from the particular node |
| Business Transactions (BTs) | BT metrics, Calls per Minute |
Based on entity liveness status of the selected time range, the Controller determines whether to count and display entities in these places:
A backend is a component that is not instrumented by an agent but one that participates in the processing of a business transaction instance. A backend may be a web server, database, message queue, or another type of service.
The agent recognizes calls to these services from instrumented code (called exit calls). If the service is not instrumented and cannot continue the transaction context of the call, the agent determines that the service is a backend component. The agent picks up the transaction context at the response at the backend and continues to follow the context of the transaction from there.
Performance information is available for the backend call. For detailed transaction analysis for the leg of a transaction processed by the backend, you need to instrument the database, web service, or other application.
This section describes how other products work with Application Monitoring to provide complete, full visibility on application health and user experience.
Infrastructure Visibility provides end-to-end visibility into the hardware and networks on which your applications run. You can use Infrastructure Visibility to identify and troubleshoot problems that affect application performance such as server failures, JVM crashes, and hardware resource utilization. There are three classes of Infrastructure Visibility functionality:
Network Visibility monitors traffic flows, network packets, TCP connections, and TCP ports. Network Agents leverage the APM intelligence of App Server Agents to identify the TCP connections used by each application. Network Visibility includes this functionality:
When you add End-User Monitoring to Application Performance Management, you can correlate business transaction performance to the user experience for those transactions. See Correlate Business Transactions for Browser RUM.
If app server agents run on the applications that serve your browser applications, you can further configure the app server agents to inject JavaScript agent into the code that runs on the browser. Access the settings to configure injection in the Applications Configuration page. See Automatic Injection of the JavaScript Agent and Assisted Injection.
In Application Monitoring, a database called by an instrumented node is considered a remote service. You can get a significant amount of information on the interaction between the application node and database, but not from the database server perspective. When using Database Visibility with Application Monitoring, you can drill down to detailed database performance information directly from application flow maps. See Access Database Visibility from Application Monitoring Views.
For those times when tracing application code does not provide enough clues to track down the cause of a problem, provides visibility into the transaction logs that can be correlated to specific business transaction requests. Log correlation visibility requires a license for both Transaction Analytics and Log Analytics. See Business Transaction and Log Correlation.