Skip to main content
ComponentsCode ProfilerEngineJS ProfilerMobile AppRPA Bot RecorderRUM JSRUM Ext
Availability2014.1

Integration approaches

Choosing by data location

Types of integrations

Options for connecting data

Build a custom integration

Writing your own connector

Deployment and configuration

Installing and tuning connectors
Custom Integrations and Plugins Extend GermainUX monitoring, analytics, and automation to applications and technologies that do not have a dedicated preconfigured integration. GermainUX can collect data through browser instrumentation, application code, APIs, databases, files, logs, operating-system commands, scripts, synthetic transactions, and other authorized interfaces. The collected data can then use the same KPIs, analytics, correlations, dashboards, notifications, and automation available for preconfigured GermainUX integrations.

​
Benefits

Custom integrations and plugins help organizations:
  • Monitor proprietary and industry-specific applications.
  • Integrate technologies not yet covered by a preconfigured GermainUX wizard.
  • Turn customer-specific technical or business data into real-time insights.
  • Correlate data across user experience, workflow, application, and infrastructure layers.
  • Preserve existing monitoring investments while centralizing analysis in GermainUX.
  • Create custom alerts, Watches, reports, and approved automated actions.
  • Adapt monitoring as applications and business requirements evolve.

​
Integration approaches

The appropriate integration depends on where the required data is available.

​
Types of integrations

​
Preconfigured integrations

GermainUX includes preconfigured monitoring for many applications, platforms, programming languages, databases, operating systems, middleware products, and infrastructure technologies. A preconfigured integration can provide:
  • Deployment wizards
  • Monitoring components
  • Data mappings
  • KPIs, measures, and pivots
  • Rules and categorizations
  • SLAs
  • Dashboards and reports
  • Correlation rules
  • Automation options
Use an existing integration whenever it covers the required technology and monitoring scope. See Integrations.

​
Configuration-based integrations

Many new technologies can be integrated without developing a new software component. A configuration-based integration can use:
  • HTTP or REST requests
  • SOAP requests
  • SQL queries
  • File and log parsing
  • Directory monitoring
  • Operating-system commands
  • Local programs
  • Shell, PowerShell, or other authorized scripts
  • Existing GermainUX browser and application instrumentation
  • Custom rules and data mappings
For example, a custom script can retrieve the status of an internal service and return a structured result. A GermainUX rule can then convert that result into a KPI for analysis.

​
Customer-specific instrumentation

Applications can emit customer-specific events to GermainUX through supported browser, mobile, API, or application instrumentation. Examples include:
  • Order Created
  • Payment Failed
  • Approval Completed
  • Case Escalated
  • Integration Delayed
  • Feature Used
  • Application Validation Failed
  • Batch Completed
  • Customer Abandoned
  • Subscription Renewed
These events can become Custom Insights and participate in business-process, conversion, productivity, error, and technology analysis.

​
Custom plugins

A custom plugin may be appropriate when the target technology requires:
  • A proprietary communication protocol
  • Specialized authentication
  • A persistent event subscription
  • Vendor-specific data transformation
  • Complex state management
  • A reusable monitoring component
  • Custom runtime instrumentation
  • Functionality that cannot be implemented safely through configuration
A custom plugin can collect data, transform it into the GermainUX data model, and expose it to the GermainUX analytics pipeline. Development, packaging, compatibility, testing, and maintenance requirements depend on the extension point and GermainUX version. Contact GermainUX Support before developing a custom binary plugin.

​
Browser and user-experience integrations

Use browser monitoring when the required insight originates in a web application.

​
RUM JS

Deploy GermainUX RUM JS in customer-controlled web applications to collect:
  • User sessions and interactions
  • Session Replay
  • Page and route activity
  • Browser performance
  • JavaScript and console errors
  • HTTP requests
  • User-visible messages
  • Custom business events
  • Workflow milestones
  • User feedback

​
RUM Extension

Use the GermainUX RUM Extension when JavaScript cannot be injected or browser-level access is required. Coverage depends on the application architecture, browser security model, extension permissions, cross-origin boundaries, and organizational approval.

​
JS Profiler

Use the GermainUX JS Profiler for targeted analysis of supported browser-side JavaScript execution.

​
Application-code integrations

Use the GermainUX Code Profiler with supported runtimes to capture application transactions and method-level execution. Depending on the runtime and configuration, code monitoring can provide:
  • Transaction duration
  • Method execution
  • Errors and exceptions
  • External service calls
  • Database activity
  • Thread and runtime information
  • Distributed transaction correlation
The Code Profiler does not analyze every programming language. Confirm support for the application runtime before deployment.

​
API and web-service integrations

The GermainUX Engine can call authorized HTTP, REST, and SOAP endpoints on a schedule. API monitoring can measure:
  • Availability
  • Response time
  • HTTP status
  • Response validity
  • Error or fault conditions
  • Returned business or technical values
Returned data can be converted into GermainUX KPIs through configuration and rules. For services that expose event subscriptions or webhooks, a customer-specific connector may be required to receive, authenticate, and transform the events.

​
Database integrations

The GermainUX Engine can connect to supported databases using the required driver and authorized credentials. Database integrations can provide:
  • Availability and connectivity monitoring
  • Database-performance metrics
  • Customer-defined SQL Query-Based Insights
  • Business-transaction status
  • Backlogs and incomplete records
  • Data-quality conditions
  • Audit or operational information
Use a dedicated, read-only database account whenever the integration only collects data. See SQL Query-Based Insights.

​
File and log integrations

The GermainUX Engine can monitor accessible files and logs locally or remotely, depending on the configured transport and permissions. Rules and parsers can extract:
  • Errors and exceptions
  • Warnings
  • Business transactions
  • Integration activity
  • Audit events
  • Performance values
  • Application state
  • Customer-defined patterns
Multiline messages, file rotation, encodings, timestamps, and parsing rules must be configured according to the source format.

​
Script and command integrations

An Engine component can execute an authorized script, command, or local program to collect data that is not available through another supported interface. The output should use a stable, machine-readable format. A GermainUX rule can parse the output and create the required KPI facts. Script-based collectors should:
  • Run non-interactively.
  • Complete within a configured timeout.
  • Return a meaningful exit code.
  • Avoid exposing credentials in command arguments or output.
  • Avoid changing production data unless explicitly authorized.
  • Produce consistent output.
  • Consume reasonable system resources.

​
Synthetic integrations

Use the GermainUX RPA Bot Recorder to create synthetic user scenarios for supported applications. Synthetic monitoring can validate:
  • Application availability
  • Authentication
  • Critical navigation
  • Search
  • Form submission
  • Checkout
  • CRM or ERP workflows
  • Connected systems and integrations
Use dedicated test accounts and prevent synthetic scenarios from generating unintended production activity.

​
Turn integrated data into insights

Collecting data is only the first part of an integration. Configure the GermainUX analytical model so that the data becomes useful. See Custom Insights, KPIs, Pivots & Measures, and Rules: Advanced Automated Analytics.

​
Correlation

Custom integration data can be correlated with other GermainUX insights using:
  • User ID
  • Session ID
  • Trace or correlation ID
  • Transaction ID
  • Order, case, or request ID
  • Host or component
  • Exact property values
  • Time proximity
For example, a custom integration event can be associated with the browser session, API transaction, application log, database activity, and server condition involved in the same business transaction. See Correlation or Tracing.

​
Notifications and automated actions

Once an integrated insight is detected, GermainUX can:
  • Send an alert.
  • Notify interested users through a Watch.
  • Generate a report.
  • Send an HTTP request or webhook.
  • Execute an authorized script or local program.
  • Run an approved SQL action.
  • Start an RPA workflow.
  • Initiate another approved diagnostic or remediation process.
A Watch is a notification mechanism applied to an existing insight; it does not create a new insight. Actions that affect users, business data, or production systems must be secured, tested, authorized, and protected against repeated execution. See Automation.

​
Build a custom integration

​
Define the requirement

Document:
  • The business or technical question to answer
  • The target application or technology
  • The available interfaces
  • The data required
  • The required collection frequency
  • Expected data volume
  • Authentication and network requirements
  • Sensitive-data considerations
  • Required KPIs and correlations
  • Notification or automation requirements

​
Select the integration method

Prefer the simplest supported method that provides the required data:
1

Existing GermainUX integration

2

RUM or application instrumentation

3

API or web-service monitoring

4

Database query

5

File or log monitoring

6

Script or command

7

Custom plugin

​
Configure data collection

Deploy the required GermainUX component and configure:
  • Endpoint, host, file, database, or application
  • Authentication
  • Network and proxy settings
  • Collection schedule
  • Timeout and retry behavior
  • Data mapping
  • Filtering
  • Privacy controls
  • Error handling

​
Configure analytics

Create or select the required:
  • Application and environment
  • Data source
  • KPI
  • Measures
  • Pivots
  • Rules
  • Categories
  • Relationships
  • SLAs

​
Configure outcomes

Configure the dashboards, reports, alerts, Watches, and approved automated actions that should use the insight.

​
Val

ts. Apply these practices:
  • Use dedicated, least-privileged accounts.
  • Store credentials through approved authentication settings.
  • Encrypt connections.
  • Restrict inbound and outbound network access.
  • Collect only the data required for the use case.
  • Mask, anonymize, or exclude sensitive information.
  • Avoid logging passwords, tokens, or confidential payloads.
  • Validate third-party certificates.
  • Restrict configuration and data access by role.
  • Define retention and deletion requirements.
  • Review scripts and custom code before deployment.
  • Test updates for compatibility with the installed GermainUX version.
  • Document ownership and maintenance responsibilities.

​
Limitations

The monitoring depth available for a technology depends on:
  • Interfaces exposed by the vendor
  • Customer permissions and licenses
  • Application ownership
  • Browser and platform security boundaries
  • Network access
  • Available identifiers
  • Data format and quality
  • GermainUX component and version
  • Privacy and compliance restrictions
A custom integration can analyze only the data that the target system exposes and the organization authorizes GermainUX to collect.

​
Deployment and configuration

  • Review existing GermainUX Integrations before creating a new one.
  • Define the required insights, data sources, collection frequency, security controls, and operational outcomes.
  • Select the appropriate GermainUX component and integration method.
  • Deploy the GermainUX Engine when server-side collection, scripts, APIs, databases, files, logs, or automation are required.
  • Deploy RUM JS, the RUM Extension, RUM Windows, Mobile monitoring, JS Profiler, Code Profiler, or the RPA Bot Recorder when applicable.
  • Configure the application, data source, KPIs, measures, pivots, rules, SLAs, relationships, and privacy controls.
  • Configure dashboards, reports, alerts, Watches, and approved automated actions.
  • Validate data accuracy, security, performance, failure handling, and compatibility before production rollout.
  • Contact GermainUX Support when a dedicated custom plugin is required.

​
Get More Information

GermainUX can help determine which monitoring, analytics and automation capabilities are appropriate for your needs. Contact GermainUX Support.

​
Get Help

Contact GermainUX Support

The GermainUX team helps you get up and running faster, empower your team, turn data into actionable insights, and optimize performance to deliver measurable business outcomes.

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.