Skip to main content
ComponentsEngineJS ProfilerMobileRPA Bot RecorderRUM JSRUM Extension
Availability2017.1 or later

Monitoring components

Pick components for your architecture

Garbage collection

Heap and allocation pressure analysis

Host and container monitoring

Tell code from infrastructure

Deployment and configuration

Setup steps for Go

​
Overview

GermainUX monitors the performance, resource usage, errors, dependencies, logs, and user experience of applications built with Go. It combines Go runtime profiling with application, API, infrastructure, database, log, synthetic, and browser monitoring to help teams identify where time and resources are consumed and which users or business services are affected.

​
Monitoring components

The required components depend on the application architecture and desired monitoring depth.

​
Go runtime profiling

GermainUX Code Profiler collects profiles made available through Go’s standard net/http/pprof package. Depending on the Go version and enabled profiles, GermainUX can analyze:
  • CPU profiles.
  • Heap allocations.
  • Current heap usage.
  • Allocation activity.
  • Goroutines.
  • Blocking activity.
  • Mutex contention.
  • Thread creation.
  • Stack traces available through the profiles.
Profiling results can help identify functions, packages, and runtime activity consuming excessive CPU, memory, or execution time.

​
CPU profiling

CPU profiles help identify:
  • Functions consuming the most processor time.
  • Expensive code paths.
  • Repeated processing.
  • Unexpected application activity.
  • Performance changes following a release.
  • Code contributing to high host or container CPU consumption.
CPU profiling should be scheduled and scoped carefully because collecting a CPU profile introduces temporary profiling overhead.

​
Heap and allocation analysis

Heap and allocation profiles can help identify:
  • Functions responsible for memory allocation.
  • Objects retained in memory.
  • High allocation volume.
  • Sustained heap growth.
  • Code paths contributing to garbage-collection pressure.
  • Potential memory-retention problems.
A growing heap or high allocation rate may indicate a problem, but it does not by itself prove a memory leak.

​
Goroutine monitoring

Goroutine profiles can help identify:
  • Unexpected goroutine growth.
  • Goroutines blocked on synchronization or I/O.
  • Repeatedly created goroutines.
  • Potential goroutine leaks.
  • Concurrency conditions associated with degraded performance.
A large goroutine count is not automatically an error. It should be evaluated against application architecture, workload, and historical behavior.

​
Mutex and blocking analysis

When the corresponding Go profiles are enabled, GermainUX can help analyze:
  • Mutex contention.
  • Blocking operations.
  • Synchronization bottlenecks.
  • Channels or locks delaying work.
  • Code paths with excessive waiting.
These profiles require the application’s runtime profiling configuration to expose the necessary data.

​
Garbage collection

GermainUX can analyze heap and allocation evidence related to garbage-collection pressure. Additional measurements such as:
  • Garbage-collection pause time.
  • Collection count.
  • Allocation rate.
  • Heap goals.
  • Live-object counts.
require an approved runtime-metrics source, Prometheus endpoint, custom metrics, logs, or another interface that exposes those values. They are not all provided by a standard CPU profile.

​
HTTP service monitoring

For Go applications serving HTTP requests, GermainUX can monitor available:
  • Endpoint availability.
  • Response time.
  • Request rate.
  • HTTP status codes.
  • Errors.
  • Response size.
  • Active connections.
  • Synthetic API transactions.
  • Server and proxy logs.
These measurements require HTTP monitoring, application instrumentation, logs, proxy data, metrics endpoints, or custom GermainUX monitoring. They are not automatically included in pprof.

​
Errors and panics

Go errors are often returned as values rather than thrown as exceptions. GermainUX can detect errors when they are exposed through:
  • Application logs.
  • HTTP status codes.
  • Custom metrics or events.
  • Monitoring endpoints.
  • Panic output.
  • Integration failures.
  • Browser or user-facing errors.
  • Custom GermainUX APIs.
Handled Go errors that are neither logged nor instrumented are not visible to GermainUX. GermainUX can categorize recurring error messages, distinguish newly observed failures, analyze trends, and correlate available errors with applications, transactions, and user sessions.

​
Logs

The GermainUX Engine can monitor Go application, container, web-server, proxy, and operating-system logs. Log analysis can detect:
  • Errors and panics.
  • Startup and shutdown events.
  • Connection failures.
  • Timeouts.
  • Database errors.
  • Integration failures.
  • Authentication problems.
  • Application-specific business failures.
  • Newly observed or recurring messages.
See File and Log Monitoring.

​
Dependencies and external services

GermainUX can monitor services used by a Go application, including:
  • Databases.
  • HTTP APIs.
  • Message queues.
  • Cache services.
  • Authentication services.
  • Third-party integrations.
  • Container and cloud services.
Depending on the available telemetry, GermainUX can analyze:
  • Availability.
  • Response time.
  • Failures.
  • Connection utilization.
  • Query performance.
  • Queue or message-processing behavior.
  • The applications and transactions affected.
Each dependency requires its own supported monitoring interface, logs, metrics, or instrumentation.

​
Database monitoring

GermainUX can monitor supported databases used by the Go application for:
  • Availability.
  • Query response time.
  • Long-running queries.
  • Connections.
  • Locks and contention.
  • Capacity.
  • Errors and logs.
  • Custom read-only query results.
Go database connection-pool metrics require application instrumentation or another metrics source exposing them.

​
Host and container monitoring

The GermainUX Engine can correlate Go profiles with infrastructure measurements such as:
  • Host or container CPU.
  • Memory.
  • Disk and I/O.
  • Network.
  • Process availability.
  • Container state and restarts.
  • Kubernetes pod and workload health.
  • Operating-system and container logs.
This helps distinguish inefficient Go code from host, container, or infrastructure constraints.

​
Browser and user-experience monitoring

When a Go service supports a browser application, GermainUX RUM JS or the RUM Extension can monitor:
  • Page and interaction performance.
  • User clicks and navigation.
  • JavaScript errors.
  • Network requests to Go APIs.
  • Browser freezes.
  • User sessions and Session Replay.
  • Application-specific workflows and outcomes.
The JS Profiler can provide deeper browser-side code and network evidence. This allows Go service performance to be analyzed in the context of the users and business processes affected.

​
End-to-end correlation

GermainUX can correlate browser, API, Go, database, log, and infrastructure evidence when common identifiers are available. Useful identifiers include:
  • Trace or correlation ID.
  • Request ID.
  • User or session ID.
  • Transaction ID.
  • Order, case, or workflow ID.
  • Application, service, host, or container.
  • Timestamp.
Correlation can connect a slow user interaction to:
1

The browser request

2

The Go HTTP handler or service

3

Runtime profiling evidence

4

A database or external dependency

5

Related logs and infrastructure conditions

The available tracing depth depends on the instrumentation and identifiers provided by the application.

​
Synthetic monitoring

The GermainUX RPA Bot Recorder and Engine can test Go-backed applications proactively. Synthetic monitoring can validate:
  • Application availability.
  • Login.
  • Critical browser workflows.
  • API endpoints.
  • Expected responses.
  • Business transactions.
  • Performance over time.
Use dedicated test accounts and non-destructive test data.

​
Business benefits

Go Application Monitoring helps organizations:
  • Identify CPU- and memory-intensive Go code.
  • Detect goroutine, blocking, and mutex contention.
  • Find errors, panics, slow APIs, and failed dependencies.
  • Determine whether degradation originates in code, a dependency, a container, or infrastructure.
  • Correlate back-end conditions with affected users and business services.
  • Reduce the time required to reproduce intermittent problems.
  • Detect regressions introduced by application releases.
  • Prioritize issues according to operational and business impact.
  • Validate performance improvements with production evidence.

​
Analytics

GermainUX can analyze Go application data through KPIs, measures, pivots, trends, drill-through views, profiling results, correlations, and outlier detection.

​
Automated analysis and actions

GermainUX can:
  • Detect abnormal profile or performance behavior.
  • Identify new and recurring errors.
  • Categorize failures.
  • Compare releases or service instances.
  • Quantify affected services and users.
  • Correlate code, application, and infrastructure evidence.
  • Notify GermainUX users through Watches.
  • Trigger approved reports, webhooks, scripts, diagnostics, or corrective workflows.
Restarts, scaling operations, configuration changes, or production commands require explicit authorization and appropriate safeguards.

​
Secure pprof access

Go pprof endpoints expose sensitive runtime information and can consume resources when profiles are requested. Do not expose /debug/pprof/ publicly. Protect access by:
  • Binding the profiling listener to an internal interface.
  • Restricting network access to authorized GermainUX Engine hosts.
  • Using an authenticated reverse proxy where required.
  • Using TLS for remote access.
  • Avoiding Internet-facing profiling ports.
  • Limiting profiling frequency and duration.
  • Reviewing production overhead.
  • Disabling profiles that are not required.
A dedicated profiling listener is preferable when it allows stricter access controls than the public application endpoint.

​
Deployment and configuration

  • Review Deploy Code Profiling and Usage Monitoring for Go.
  • Add the approved Go pprof package and listener to the application.
  • Restrict the profiling endpoint to the GermainUX Engine.
  • Deploy the GermainUX Engine.
  • Import the Go monitoring configuration supplied with the GermainUX distribution when required.
  • Run the Golang wizard to create the profiler monitor.
  • Configure File and Log Monitoring for Go application and infrastructure logs.
  • Configure API, database, dependency, operating-system, Docker, or Kubernetes monitoring as required.
  • Deploy GermainUX RUM JS or the RUM Extension for browser applications supported by the Go service.
  • Deploy the GermainUX JS Profiler for deeper browser-side diagnostics.
  • Deploy the GermainUX RPA Bot Recorder for synthetic user scenarios.
  • Configure KPIs, SLAs, Watches, reports, and approved actions.
  • Validate profiling security, accuracy, and overhead before production rollout.

​
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.