Community-shared tools & configurations for AppSense Environment Manager, Application Manager and Performance Manager

How to Create AppSense Health Checks With Integrated Performance Monitors

A reliable AppSense health check should do more than confirm that a service is running. It should show whether users can sign in, receive the right policy, launch applications, access mapped resources, and work at an acceptable speed. Integrating performance monitors turns a basic availability test into a practical view of the user experience.

This approach is especially useful in Australian environments, where a single organisation may support staff in Sydney, Melbourne, Brisbane, Perth, and regional locations. Network distance, NBN service quality, mobile working, and different office configurations can all affect an AppSense-managed session. A check that passes in a Melbourne data centre may still reveal delays for a user in Perth or a remote worker on a busy connection.

The most effective design combines configuration validation, synthetic transactions, session data, and resource counters. It also records enough context to separate an AppSense policy issue from a Windows, network, storage, or application problem. With a consistent baseline, administrators can spot gradual degradation before a queue of support tickets appears.

Define The Scope Of The Health Check

Start by deciding what “healthy” means for the AppSense estate. A useful scope normally covers the management infrastructure, endpoint agents, user sessions, policy delivery, application launches, and the performance of key supporting services. The result should be a repeatable test rather than a one-off inspection of a console.

Separate checks into availability, correctness, and performance. Availability confirms that a service or agent responds. Correctness verifies that the expected policy, configuration, drive mapping, or application control rule is applied. Performance measures how long those actions take and whether they consume excessive CPU, memory, disk, or network resources.

Multiple users on one machine need particular attention. Shared desktops, terminal servers, and virtual desktop hosts can behave very differently from a dedicated laptop. Review session handling guidance before setting thresholds, because an apparently healthy host may still be overloaded when several profiles initialise at the same time.

Select Signals And Practical Thresholds

A health check becomes useful when every result has a clear meaning. Typical signals include agent service state, policy refresh completion, logon duration, application launch time, profile load time, CPU utilisation, available memory, disk latency, network round-trip time, and failed policy actions. Capture the timestamp, device name, user context, AppSense component, and policy version with each result.

Avoid treating every threshold as universal. A ten-second application launch may be normal for a large engineering package but unacceptable for a small office productivity tool. Establish a baseline from healthy devices, then define warning and critical levels around that baseline. Percentiles are often more informative than averages because a handful of slow sessions can disappear inside a broad average.

For Australian sites, record location and connection type as dimensions in the monitoring data. A Brisbane office using a local host pool should not be assessed against the same network latency expected from a Perth user accessing services across the country. Include a maintenance window so overnight backup, patching, or policy replication does not create false alarms during the early-morning arvo handover.

Synthetic checks can also validate ordinary browser access without making an external website a dependency. For example, a controlled test profile might reach a community information resource such as a small church website to confirm basic DNS, proxy, and browser behaviour. The destination is only a test target; the important result is whether the managed session handles the request consistently.

Build A Repeatable Collection Method

Use a standard record for every health-check run. At minimum, store the check name, endpoint, operating system, AppSense product and version, policy revision, user type, site, timestamp, duration, result, and diagnostic message. A structured format such as CSV or JSON makes it easier to compare results over time and import them into an existing monitoring platform.

Collect data at three levels. The first is the management layer, including service availability, database connectivity, configuration replication, and console responsiveness. The second is the endpoint layer, including agent state, event logs, policy processing, and local resource usage. The third is the experience layer, including sign-in, application launch, file access, and logoff timing.

Event logs should be correlated with performance counters rather than reviewed in isolation. A policy error that appears at 9:03 may explain a spike in logon duration at the same time. Likewise, high disk queue length during profile processing can point to storage contention instead of a faulty AppSense configuration.

Keep the test account safe and predictable. Use a non-privileged account with a known policy set, a small number of representative applications, and data that can be recreated. If browser connectivity is part of the check, a support resource such as Duo help information can serve as a controlled example of an external destination, while the health-check record should clearly distinguish internet reachability from AppSense service health.

Integrate Monitors With The Management Console

The monitoring view should place related signals together. A dashboard might show active alerts, failed policy actions, median logon time, slowest application launches, endpoint check-in age, and resource pressure by site. Use separate views for infrastructure administrators, service desk staff, and application owners so each group sees useful detail rather than a wall of counters.

A custom dashboard can combine AppSense results with Windows performance data and external monitoring alerts. Relevant tiles might include the number of unhealthy endpoints, hosts above CPU or memory thresholds, policy versions in use, and the ten slowest sessions in the last hour. Link every alert to the underlying device, user session, event record, or test transaction so an operator can move from detection to diagnosis quickly.

Teams building their own view can use this example of a custom console dashboard as a starting point. The design should favour clear status categories, short labels, and filters for product version, office, host pool, and policy ring. A green status that hides missing data is worse than an amber status that accurately signals incomplete monitoring.

Use alert suppression carefully. If ten users on one host fail because a single service stopped, create one infrastructure incident with affected-session context instead of ten unrelated tickets. Conversely, if one endpoint repeatedly misses policy refresh while its peers are healthy, preserve that individual alert rather than folding it into a broad site warning.

Test User Sessions And Application Behaviour

A complete health check should reproduce the sequence that matters to users. A practical synthetic journey can sign in, wait for the environment to initialise, confirm a policy marker, launch a representative application, open a test file, access a mapped location, and sign out. Measure each step independently so a slow result identifies the stage at fault.

Run tests against several user profiles. A standard office worker, a restricted user, a shared-host session, and a remote worker may receive different configurations. This is particularly important when Environment Manager rules, application control, privilege policies, or personalisation settings vary by group.

For shared machines, perform concurrent tests rather than relying on a single successful session. Start several sessions within a short interval and watch CPU ready time, memory pressure, profile activity, disk latency, and application launch duration. This helps reveal a capacity issue that would remain invisible during a quiet test.

Include Australian network patterns in the test schedule. A Sydney-based synthetic endpoint and a Perth-based endpoint may experience different paths to the same service, while regional staff may connect through slower or less predictable links. Test during the business day as well as outside peak periods, and label results by site instead of treating the whole national environment as one network.

Operationalise Reporting And Escalation

Health checks should create a trend, not just a pass-or-fail snapshot. Report daily availability, weekly threshold breaches, median and high-percentile timings, recurring policy errors, and the number of endpoints with stale data. Trend lines can expose a gradual increase in logon time after a policy change or a steady rise in resource use on a host pool.

Write alerts in operational language. “Policy processing failed for user group A on host B after configuration version C was deployed” is more useful than “AppSense unhealthy.” Include the first observed time, last observed time, affected scope, evidence collected, and the next diagnostic action. This reduces repeated triage by the service desk.

Use severity based on user impact. A missing optional personalisation rule may be informational, while failed sign-in or widespread application control errors should be critical. A single slow endpoint may require investigation, but a Perth office reporting elevated logon times across several hosts deserves a broader network and capacity review.

Set an owner for each category of alert. The AppSense administrator may handle policy and agent issues, the Windows team may own services and event logs, the network team may investigate latency or packet loss, and an application team may review launch delays. Shared ownership without a clear first responder tends to produce alerts that remain open until users escalate them.

Troubleshoot With Evidence And Version Context

When a check fails, compare the result with a known-good device. Check product and agent versions, policy revision, operating system build, host pool, user group, and site. Differences often reveal whether the problem was introduced by a deployment, limited to a particular image, or associated with a location.

Review the timeline in order: endpoint availability, user authentication, policy retrieval, policy processing, profile or personalisation activity, application launch, and resource consumption. This sequence prevents administrators from blaming the first visible error when a later event is the actual cause. Preserve logs before restarting services or clearing temporary data.

Version awareness matters because counters, event formats, and available management features can vary across releases. Store the product version alongside every health-check record and retain a short history after upgrades. A performance change that coincides with a new agent or policy engine should be investigated differently from an isolated endpoint failure.

The following comparison helps select the right monitoring layer for each purpose:

Monitoring approach Best use Strength Common limitation
Service and agent checks Confirming availability Fast and easy to automate Cannot prove the user experience is good
Event and policy checks Validating configuration processing Shows specific failures and policy context Requires careful log correlation
Windows performance counters Finding resource pressure Helps identify CPU, memory, disk, and network causes Thresholds vary by workload
Synthetic user journeys Measuring real workflow timing Closely reflects sign-in and application experience Needs safe test accounts and maintenance
Console dashboard integration Operating the service at scale Gives teams a shared view of trends and alerts Poor design can hide important detail

Use the comparison as a layered model rather than selecting one method. Service checks tell you whether something is present, policy checks show whether it is working correctly, performance counters explain pressure, and synthetic journeys demonstrate what the user experiences.

A mature implementation stores results where administrators can search by site, product version, policy, endpoint, and time period. It should also make it easy to share a failed check with the AppSense community without exposing usernames, internal hostnames, or sensitive policy content.

Publish reusable scripts, configuration examples, and dashboard definitions in a controlled library. Keep a version note with each resource, describe its assumptions, and explain how to remove or disable it. That makes the material safer for other administrators and easier to maintain when the environment changes.

Build your own repeatable AppSense health-check workflow by joining the AppSense Exchange. Sharing tested monitors, performance baselines, dashboard patterns, and anonymised troubleshooting results helps Australian teams compare practical approaches and resolve problems before they become widespread service interruptions.