Configuring Monitoring and Automation for Java with GermainUX

Configure Monitoring & Automation for Java

Once the GermainUX Java Agent and/or Engine is deployed, configure the monitoring scope, data collection, analytics, alerts, and automation appropriate for your Java environment.

GermainUX configuration can range from lightweight JVM health monitoring to deep transaction, database, API, code-level, user-impact, and business-process analysis.

⚙️ Configure the Java Agent

Java Agent capabilities are controlled through the application's agent.properties file.

Monitoring can be enabled or disabled individually, allowing each Java application to collect only the telemetry required for its use case.

🌐 HTTP Monitoring

GermainUX can monitor inbound application requests and outbound HTTP calls.

Enable inbound Servlet monitoring and outbound HTTP monitoring:

agent.feature.servlet.enabled=true
agent.feature.outboundHttp.enabled=true

Monitoring can capture information such as:

• URL

• HTTP method

• Response code

• Response time

• Payload size

• Outbound target

• Transaction failures

Session Correlation

HTTP session ID collection can be enabled when session-level correlation is required:

agent.feature.servlet.collectSessionId=true

For web-based Java applications, this can help correlate backend transactions with user activity and workflows monitored by GermainUX.

🗄️ JDBC / SQL Monitoring

Enable JDBC monitoring:

agent.feature.jdbc.enabled=true

GermainUX can capture:

• SQL statement

• Execution time

• Error state

• Slow database activity

• Database impact on application transactions

Low-value or repetitive SQL statements such as health checks can be excluded:

agent.feature.jdbc.exclusions.0=SELECT 1 FROM DUAL
agent.feature.jdbc.exclusions.1=SELECT @@session.tx_isolation

Additional exclusions can be added using sequential indexes.

📨 JMS Monitoring

Enable JMS monitoring:

agent.feature.jms.enabled=true

GermainUX can monitor:

• Destination

• Inbound/outbound direction

• Processing time

• Errors

Message-body collection can be disabled when messages contain sensitive information or when payload size could create unnecessary overhead:

agent.feature.jms.collectMessageBody=false

Always review data-privacy requirements before collecting message content.

🔎 Elasticsearch Monitoring

Elasticsearch monitoring is available but disabled by default.

Enable it with:

agent.feature.es.enabled=true

GermainUX can monitor Elasticsearch REST activity including:

• Index

• Operation

• Response time

📊 JVM & Process Monitoring

Enable JVM/process metrics:

agent.feature.processMetrics.enabled=true
agent.feature.processMetrics.interval=60

GermainUX can collect JVM metrics such as:

• Heap memory

• Non-heap memory

• Garbage collection activity

• Thread counts and states

• Heap histograms

Heap histogram collection can be disabled independently:

agent.feature.processMetrics.heapHistogram=false

Adjust the collection interval based on the required monitoring granularity and acceptable overhead.

🧵 Thread Pool Monitoring

Enable thread-pool monitoring:

agent.feature.threadPool.enabled=true

GermainUX can monitor thread-pool activity to identify capacity constraints and thread starvation.

Specific metrics can be selected when required:

agent.feature.threadPool.metrics.0=PoolSize
agent.feature.threadPool.metrics.1=ActiveCount

🔗 Connection Pool Monitoring

Enable connection-pool monitoring:

agent.feature.connectionPool.enabled=true

GermainUX can monitor:

• Active connections

• Idle connections

• Waiting threads

• Wait time

• Pool exhaustion

Dedicated HikariCP monitoring is also available:

agent.feature.connectionPool.hikari=true

Specific metrics can be selected:

agent.feature.connectionPool.metrics.0=WaitTime

⏱️ Configure CPU Profiling

GermainUX's CPU Profiler uses stack sampling to identify CPU-intensive code paths while minimizing application overhead.

Enable CPU profiling:

agent.feature.cpuProfiling.enabled=true

Configure the sampling window:

agent.feature.cpuProfiling.duration=60
agent.feature.cpuProfiling.interval=10000

Results can be analyzed in GermainUX using visualizations such as flame graphs and transaction waterfalls.

Limit Profiling Scope

Exclude framework or low-value packages:

agent.feature.cpuProfiling.blacklist=org.hibernate,org.apache.catalina

Or restrict profiling to your application code:

agent.feature.cpuProfiling.whitelist=com.mycompany.myapp

Use filtering to reduce noise, data volume, and monitoring overhead.

On-Demand CPU Profiling

CPU profiling can also be controlled at runtime through JMX:

com.germainsoftware:type=ProfilerAgent

This allows profiling to be activated for a specific workload without restarting the JVM.

🔧 Configure Custom Method Monitoring

GermainUX can instrument application-specific Java methods, classes, or packages that are not covered by standard HTTP, JDBC, JMS, or other built-in monitoring.

Enable method monitoring:

agent.feature.method.enabled=true

Monitor a Specific Method

agent.feature.method.0.path=com.mycompany.myapp.OrderService.processOrder
agent.feature.method.0.type=Java:ProcessOrder

Monitor an Entire Class

agent.feature.method.1.path=com.mycompany.myapp.OrderService
agent.feature.method.1.type=Java:OrderService

Monitor a Package

agent.feature.method.2.path=com.mycompany.myapp.service
agent.feature.method.2.type=Java:Service

Package-level instrumentation should be used carefully because monitoring large numbers of methods can increase application overhead and telemetry volume.

🔍 Configure Method-Level Data Collection

When required for troubleshooting, GermainUX can capture method arguments and return values:

agent.feature.method.0.includeArguments=true
agent.feature.method.0.includeReturnValue=true

Non-public methods can also be instrumented:

agent.feature.method.0.publicAccessOnly=false

Only enable these capabilities when necessary and after reviewing privacy, security, and performance requirements.

🔗 Configure User & Transaction Correlation

For web-based applications, Java telemetry can be correlated with other GermainUX monitoring data to provide visibility across the complete user and application journey:

User Action → Browser → Java Transaction → API / Service → Database

This can help teams determine:

• Which backend transaction affected a user

• Which Java error caused a workflow to fail

• Which SQL call contributed to a slow transaction

• Which backend issue caused repeated user actions

• Which technical issue affected productivity, adoption, conversion, or abandonment

When GermainUX User Monitoring and Session Replay are deployed, backend insights can be combined with the actual user experience for faster root-cause analysis.

🔐 Configure Data Privacy & Exclusions

Review all monitored data before enabling detailed instrumentation in production.

Depending on the application, this can include:

• SQL text

• HTTP/session information

• JMS messages

• Method arguments

• Return values

• User identifiers

• Business data

Configure exclusions or disable unnecessary data collection wherever sensitive information does not need to be monitored.

The objective should be to collect the information necessary for troubleshooting and analysis while minimizing unnecessary or sensitive data collection.

📊 Configure KPIs, Dashboards & Reports

Java telemetry collected by GermainUX can be analyzed through configurable real-time KPIs, dashboards, and automated reports.

Examples include:

• Application availability

• Error rate

• Response time

• JVM memory and garbage collection

• Slow transactions

• CPU hotspots

• Database performance

• API performance

• Connection-pool utilization

• Thread-pool utilization

• Business transaction performance

• User impact

Dashboards and reports can combine Java telemetry with data from other GermainUX monitoring sources to provide application, user, process, and business context.

🚨 Configure Alerts & SLAs

Configure alerts for conditions that require attention, such as:

• New Java errors

• Error-frequency increases

• Slow transactions

• JVM resource saturation

• Excessive garbage collection

• CPU hotspots

• Connection-pool exhaustion

• Thread-pool saturation

• Slow SQL

• API failures

• Application availability issues

• SLA violations

Thresholds, frequency, time windows, recipients, and escalation logic can be customized according to operational requirements.

🤖 Configure Automation

GermainUX can trigger automated actions when defined Java application conditions occur.

For example:

Detect → Analyze → Alert → Create Ticket → Trigger Action

Depending on the use case, automation can include:

• Alerts and notifications

• Ticket or incident creation

• Script execution

• Program / RPA execution

• HTTP calls

• SQL execution

• SSH execution

• Scheduled actions

• Custom workflows

• Remediation actions

Automation can be triggered by technical conditions, SLA violations, user impact, business impact, or combinations of monitored events.

Use automated remediation selectively for well-understood and safely recoverable conditions.

⚖️ Tune Monitoring Overhead

Monitoring depth should match the diagnostic requirements of each environment.

For production environments:

1. Start with JVM metrics and critical transactions.

2. Enable HTTP, JDBC, pools, and other relevant integrations.

3. Add CPU profiling where deeper performance analysis is required.

4. Instrument specific business-critical methods when built-in monitoring does not provide sufficient visibility.

5. Avoid unnecessarily broad package-level instrumentation.

6. Adjust sampling and collection intervals where appropriate.

7. Review data volume and application overhead after configuration changes.

This progressive approach provides deep visibility where needed while minimizing unnecessary monitoring overhead.

✅ Validate the Configuration

After making configuration changes:

• Restart the JVM when required for instrumentation changes.

• Confirm that expected telemetry is being collected.

• Validate transaction and application naming.

• Confirm exclusions are working correctly.

• Review CPU and application overhead.

• Test alerts and SLA thresholds.

• Test automation actions in a non-production environment.

• Validate user/backend correlation where applicable.

• Confirm that sensitive data is not being collected unintentionally.

Progressively expand monitoring once the initial configuration has been validated.

ℹ️ Get Help

The Germain Team can help you set this up. Contact GermainUX Support.