Plugins (Integrate to other technologies)

⚙️ 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:

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

Data source	GermainUX approach	Examples
Customer-controlled web application	RUM JS	User activity, Session Replay, performance, errors, network requests, business events
Web application that does not permit script injection	RUM Extension	Browser activity, Session Replay, errors, performance, and network requests
Native Windows application	RUM Windows	User activity, application lifecycle, freezes, crashes, and Session Replay
Mobile application	GermainUX Mobile App or SDK	Mobile sessions, screens, interactions, errors, crashes, and transactions
JavaScript execution	JS Profiler	Function execution time and browser-side JavaScript bottlenecks
Supported backend runtime	Code Profiler	Method execution, transaction traces, errors, and supported runtime activity
REST or HTTP API	Engine	Availability, response time, status, response validation, and returned data
SOAP service	Engine	SOAP transaction availability, duration, faults, and response validation
Database	Engine	Database availability, performance, and query-based business or technical insights
File or log	Engine	Errors, exceptions, transactions, audit events, and customer-defined patterns
Server or operating system	Engine or Agent	CPU, memory, disks, processes, services, and availability
Message queue or middleware	Engine	Queue depth, consumers, errors, throughput, and supported integration activity
Command or script	Engine	Customer-specific data collection and diagnostics
Synthetic user scenario	RPA Bot Recorder and Engine	Proactive availability and workflow validation
External monitoring platform	API, HTTP, database, file, or custom connector	Import external events and metrics for correlation and analysis
External operational system	HTTP, script, program, SQL, or RPA action	Create tickets, send data, run diagnostics, or initiate approved remediation

📦 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:

Feature
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:

Method
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:

Event
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:

Requirement
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:

Item
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:

Capability
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:

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:

Capability
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:

Extracted item
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:

Requirement
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:

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

Configuration	Purpose
Data source	Identifies where the data originated
Application and environment	Associates the data with the monitored service
KPI	Defines what event, transaction, measurement, or condition occurred
Measure	Defines the numerical value to calculate
Pivot	Defines how results can be segmented
Rule	Detects, maps, enriches, or categorizes conditions
SLA	Defines the expected operating condition
Relationship	Correlates the insight with other KPIs
Privacy rule	Masks, anonymizes, or excludes sensitive data
Dashboard or report	Presents the insight to the appropriate audience
Automation	Notifies users or initiates an approved response

See Custom Insights, KPIs, Pivots & Measures, and Rules: Advanced Automated Analytics.

🔗 Correlation

Custom integration data can be correlated with other GermainUX insights using:

Identifier
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:

Action
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:

Item
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:

Existing GermainUX integration
RUM or application instrumentation
API or web-service monitoring
Database query
File or log monitoring
Script or command
Custom plugin

⚙️ Configure data collection

Deploy the required GermainUX component and configure:

Configuration
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:

Analytic item
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:

Practice
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:

Factor
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

For your custom integration
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.

Component: Code Profiler, Engine, JS Profiler, Mobile App, RPA Bot Recorder, RUM JS, RUM Ext

Feature Availability: 2014.1