Skip to main content
ComponentsAgentEngine
Availability2022.1 or later

GermainUX Components

Agent and engine parts

Requirements

Java runtime prerequisites

Transaction Timing Detail

Latency breakdown per transaction

JMX

Runtime MBeans via JMX

​
Digital Experience Monitoring, Observability, and Automated Analysis for Java using GermainUX

GermainUX provides comprehensive, low-overhead monitoring, analytics, and automation for Java applications—helping organizations detect performance bottlenecks, user friction, workflow inefficiencies, and system failures in real time. Unlike traditional APM tools that focus primarily on backend performance, GermainUX correlates application performance, user journeys, workflow execution, and business outcomes to accelerate root-cause analysis and improve productivity, reliability, and adoption.

​
GermainUX Components

​
GermainUX Agent / Code Profiler

The GermainUX Agent attaches to the JVM at startup using the standard Java Instrumentation API. It collects detailed runtime telemetry including transaction timing, resource consumption, method execution, and infrastructure metrics, then securely streams the data to the GermainUX platform for analysis, alerting, reporting, and AI-driven insights.

​
GermainUX Engine

The GermainUX Engine runs independently from the JVM and provides high-level JVM health monitoring, workflow automation, anomaly detection, self-healing actions, and operational orchestration. The Engine can automatically trigger alerts, execute scripts, open incidents, or initiate remediation workflows when predefined conditions are met.

​
Requirements

  • GermainUX version
  • JRE (current agent)
  • JRE (legacy agent)

​
Monitored Entities

​
Connection Pools

Monitor database connection pool behavior including:
  • Active connections
  • Idle connections
  • Waiting thread counts
  • Pool exhaustion conditions
Dedicated monitoring is available for connection pool implementations such as HikariCP.

​
CPU Profiling

GermainUX provides low-overhead stack-based CPU sampling to identify CPU-intensive code paths and inefficient execution patterns. Results are visualized through:
  • Flame graphs
  • Waterfall charts
  • Method-level CPU breakdowns
  • Thread hotspot analysis
Sampling duration and intervals are fully configurable.

​
Custom Method Monitoring

Instrument specific classes, methods, packages, or business workflows to track execution performance for application logic not covered by built-in instrumentation. Examples include:
  • Order submission workflows
  • Customer lookup operations
  • Payment authorization logic
  • API orchestration flows

​
Database Monitoring (JDBC)

Track SQL execution and database behavior across supported JDBC drivers. Captured metrics include:
  • SQL query text
  • Execution time
  • Transaction throughput
  • Error state
  • Slow query detection
  • Retry behavior
Health-check queries and driver-internal SQL can be excluded via configuration.

​
Elasticsearch Monitoring

Monitor REST-based search and indexing operations. Captured telemetry includes:
  • Index name
  • Operation type
  • Response time
  • Error rate
  • Payload size
Support for Elasticsearch monitoring is available and disabled by default.

​
HTTP Transactions

​
Inbound Requests

Monitor inbound servlet or web requests including:
  • Request URL
  • HTTP method
  • Response code
  • Response time
  • Payload size
  • Session correlation
Optional session ID capture enables correlation with user workflows and session replay.

​
Outbound Requests

Monitor outbound REST or HTTP service calls:
  • Target URL
  • Response time
  • Status code
  • Failure rate
  • Retry behavior
This enables visibility into slow or failing downstream services.

​
Messaging (JMS)

Monitor asynchronous messaging and event-driven architectures. Supported telemetry includes:
  • Destination
  • Queue / Topic
  • Direction (inbound / outbound)
  • Processing time
  • Failure state
  • Retry attempts
Message body capture is optional and configurable.

​
Process Metrics

JVM-level metrics are collected on configurable intervals. Collected metrics include:
  • Heap memory usage
  • Non-heap memory usage
  • Garbage collection activity
  • Thread counts and thread states
  • Class loading statistics
  • Heap histograms
These metrics help identify memory leaks, excessive GC activity, and resource saturation.

​
Thread Pools

Monitor application thread pools and executor services. Metrics include:
  • Active threads
  • Idle threads
  • Queue depth
  • Wait time
  • Rejected tasks
Useful for identifying thread starvation and capacity bottlenecks.

​
Transaction Timing Detail

For each monitored transaction, GermainUX can collect:
  • Wall clock time
  • Thread CPU time
  • Database wait time
  • Network wait time
  • I/O wait time
  • Lock contention time
  • Async operation timing (for example Future.get())
This enables highly granular latency breakdown analysis.

​
JMX

The agent registers MBeans for runtime inspection. These are accessible via any JMX client such as VisualVM or JConsole: JMX should be disabled on IBM JVM (agent.jmx.enabled=false).

​
Session Replay & Workflow Analytics

GermainUX can correlate backend Java telemetry with actual user sessions and workflow execution. This enables teams to answer questions such as:
  • Which workflow step caused abandonment?
  • Which screens are slow or error-prone?
  • Which backend transactions impacted user productivity?
  • Which errors caused repeated user actions?
Unlike traditional Java monitoring tools, GermainUX helps quantify business impact, not just technical degradation. Examples of measurable impact:
  • Increased average handle time
  • Lower conversion rates
  • Higher cart abandonment
  • Reduced employee productivity
  • Increased support escalations

​
Additional Resources

​
Get Help

Contact GermainUX Support

The Germain Team can help you set this up.

Can't find what you need?

Search all GermainUX docs with Ctrl + K, or use the feedback buttons at the bottom of this page to tell us what is missing.

The content of this document is proprietary to GERMAIN SOFTWARE.