Configure User Feedback - GermainUX Docs

ServiceAnalyticsAutomation

Availability2017.1 or later

Deploy

RUM JS, Extension, Windows

Configure

Popup settings

Analyze

Review feedback

Troubleshoot

Common fixes

Overview

Configure GermainUX User Feedback to collect feedback directly from users while they interact with monitored web and native Windows applications. Depending on the application, User Feedback can be deployed using:

Deployment Option	Notes
GermainUX RUM JS	Deploy into web application pages and execution context.
GermainUX RUM Extension	Use when extension-based deployment is required or preferred.
GermainUX RUM Windows	For native Windows application monitoring.

Feedback can be associated with available user, application, session, activity, error, performance, and Session Replay context, helping teams connect: What the user said + What the user experienced This page covers deployment, configuration, advanced configuration, validation, API integration, troubleshooting, security, and privacy.

Before You Begin

Before configuring User Feedback:

Checklist	Action
Deploy the appropriate GermainUX Real User Monitoring component.	Ensure correct RUM component is installed.
Verify that monitored user activity is reaching GermainUX.	Confirm incoming monitoring data.
Enable Session Replay if feedback-to-session correlation is required.	Turn on Session Replay when needed.
Determine which applications and users should have access to User Feedback.	Define scope of feedback collection.
Determine what feedback and comments should be collected.	Specify required feedback fields and limits.
Review your organization’s privacy, security, consent, and data-retention requirements.	Align configuration with policies.

Choose a Deployment Method

Select the RUM component appropriate for the monitored application.

Component	Use When
GermainUX RUM JS	Monitoring a web application where the GermainUX monitoring script can be deployed directly into the required pages and execution context.
GermainUX RUM Extension	Monitoring a web application when direct RUM JS deployment is unavailable or browser-extension deployment is required or preferred.
GermainUX RUM Windows	Monitoring a native Windows application and collecting feedback from Windows application users.

Only one RUM deployment method is normally required for a given application.

Deploy User Feedback

RUM JS

Use GermainUX RUM JS when the monitoring script can be deployed directly into the monitored web application. The deployment process is:

Step	Action
Deploy and validate RUM JS.	Install and confirm RUM JS operation.
Enable User Feedback in the applicable Monitoring Profile’s Init Script.	Modify Init Script to enable plugin.
Customize the Feedback Popup if required.	Adjust appearance, labels, and behavior.
Test the configuration with a controlled user session.	Run QA with test users.
Verify feedback, session context, Session Replay, and access permissions.	Ensure end-to-end visibility and access control.

RUM Extension

Use GermainUX RUM Extension when the required monitoring script cannot be deployed directly into the application’s required execution context or when browser-extension deployment is preferred. For example, some SaaS applications may require extension-based monitoring to provide the required browser context. The deployment process is:

Step	Action
Deploy and validate RUM Extension.	Install extension and confirm operation.
Configure User Feedback for the applicable monitored application and users.	Adjust extension settings per app/users.
Test the configuration with a controlled user session.	Run QA with test users.
Verify feedback and available browser/session context.	Confirm context data is attached.
Verify Session Replay when enabled.	Check replay linkage.

RUM Windows

Use GermainUX RUM Windows to collect User Feedback from monitored native Windows applications. The deployment process is:

Step	Action
Deploy and validate RUM Windows.	Install RUM Windows and confirm telemetry flow.
Configure User Feedback for the applicable Windows application and users.	Set feedback options for Windows app.
Test feedback using a controlled user session.	Use test users in Windows environment.
Verify that submitted feedback reaches GermainUX.	Confirm telemetry and feedback ingestion.
Verify the associated Windows application and session context.	Ensure context is attached correctly.
Verify Session Replay when enabled.	Check replay availability.

For RUM JS, the Feedback Popup is configured in the applicable Monitoring Profile’s Init Script. The popup is disabled by default and must be enabled for each applicable Monitoring Profile. Set settings.plugins.feedback.enabled to true.

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);

settings.plugins.feedback.enabled = true;

germainApm.start(settings);

This enables the Feedback Popup using its default settings. No configuration is required to keep the popup disabled because enabled defaults to false. To disable it explicitly:

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);

settings.plugins.feedback.enabled = false;

germainApm.start(settings);

The popup’s appearance, labels, position, buttons, and comment form can be customized. The following example enables User Feedback and customizes the positive and negative buttons, labels, colors, comment form, and screen position:

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);

settings.plugins.feedback = {
    enabled: true,
    positive: {
        icon: 'data:image/jpeg;base64,...',
        label: 'I like this page',
        backgroundColor: 'green'
    },
    negative: {
        icon: 'data:image/jpeg;base64,...',
        label: 'This page contains an error',
        backgroundColor: 'red'
    },
    position: 'bottom-right',
    comment: {
        position: 'right',
        commentHint: 'Tell us more',
        emailHint: 'Email',
        sendHint: 'Send'
    }
};

germainApm.start(settings);

Advanced Configuration Reference

The settings.plugins.feedback object provides detailed control over the RUM JS Feedback Popup.

FeedbackSettings

type FeedbackSettings = {
    /** Enable the feedback buttons. Default: false. */
    enabled?: boolean;

    /** Positive-feedback button settings. */
    positive?: FeedbackButton;

    /** Negative-feedback button settings. */
    negative?: FeedbackButton;

    /** Popup position. Default: 'bottom-left'. */
    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';

    /** Comment-form settings. */
    comment?: {
        /** Position relative to the feedback buttons. Default: 'right'. */
        position?: 'left' | 'right';

        /** Comment placeholder. Default: 'Tell us more'. */
        commentHint?: string;

        /** Email placeholder. Default: 'Email'. */
        emailHint?: string;

        /** Submit-button label. Default: 'Send'. */
        sendHint?: string;

        /** Additional styles applied to the comment-form elements. */
        styles?: Record<
            'container' | 'email' | 'comment' | 'send' | 'close',
            Record<string, string>
        >;
    };
};

FeedbackSettings Properties

Property	Type	Default	Description
`enabled`	`boolean`	`false`	Enables or disables the Feedback Popup.
`positive`	`FeedbackButton`	Default positive button	Configures the positive-feedback button.
`negative`	`FeedbackButton`	Default negative button	Configures the negative-feedback button.
`position`	`top-left`, `top-right`, `bottom-left`, `bottom-right`	`bottom-left`	Defines where the Feedback Popup appears.
`comment`	`object`	—	Configures the comment form.

FeedbackButton

type FeedbackButton = {
    /** Image supplied as a data URI. */
    icon?: string;

    /** Button title displayed on hover. */
    label?: string;

    /** Button background color. */
    backgroundColor?: string;

    /** Parent element receiving the button. Default: document.body. */
    parentSelector?: string;

    /** Additional styles applied to the button. */
    styles?: Record<string, string>;
};

FeedbackButton Properties

Property	Type	Default	Description
`icon`	`string`	GermainUX default icon	Image displayed for the feedback button, supplied as a data URI when customized.
`label`	`string`	GermainUX default label	Button title displayed on hover.
`backgroundColor`	`string`	GermainUX default color	Background color of the feedback button.
`parentSelector`	`string`	`document.body`	Parent element receiving the feedback button.
`styles`	`Record<string, string>`	—	Additional styles applied to the button.

Default button settings include the GermainUX thumbs-up and thumbs-down icons, standard accessible labels, and default positive and negative colors. The position property determines where the Feedback Popup appears. Supported values:

top-left
top-right
bottom-left
bottom-right

Default:

position: 'bottom-left'

Choose a position that does not interfere with application navigation, chat widgets, accessibility controls, or other interactive elements.

Comment Configuration

The comment object controls the form used to collect additional feedback.

Property	Type	Default	Description
`position`	`left` or `right`	`right`	Positions the comment form relative to the feedback buttons.
`commentHint`	`string`	`Tell us more`	Placeholder displayed in the comment field.
`emailHint`	`string`	`Email`	Placeholder displayed in the email field.
`sendHint`	`string`	`Send`	Label displayed on the submit button.
`styles`	`Record`	—	Additional styles applied to supported comment-form elements.

Comment Styles

Custom styles can be applied to:

container
email
comment
send
close

For example:

comment: {
    position: 'right',
    commentHint: 'Tell us about your experience',
    emailHint: 'Email',
    sendHint: 'Submit'
}

Use custom styling when the Feedback Popup needs to align with the visual design of the monitored application.

Parent Element

By default, feedback buttons are added to:

document.body

Use parentSelector when the feedback control needs to be attached to another element. For example:

positive: {
    parentSelector: '#application-container'
}

When using a custom parent element, verify that:

Check	Reason
The selector exists when User Feedback initializes.	Element must be present at init time.
The element’s layout does not hide the Feedback Popup.	Ensure visibility and accessibility.
The configuration works across applicable pages and application states.	Confirm consistent behavior.

Validate the Deployment

Perform a controlled test before broad rollout.

Step	Action
Open the monitored application as a test user.	Start a test session.
Confirm that the applicable Real User Monitoring component is active.	Check RUM telemetry.
Navigate to a page or screen where User Feedback should be available.	Go to target screen.
Confirm that the feedback controls appear correctly.	Verify UI appearance.
Submit positive feedback with a test comment.	Send positive feedback.
Submit negative feedback in a separate test session.	Send negative feedback in another session.
Confirm that both feedback events appear under the User Feedback KPI.	Check KPI ingestion.
Verify that the application, page or screen, user, and session context are correct.	Confirm context metadata.
Open the associated Session Replay and confirm that the feedback event appears at the expected point in the session.	Validate replay linkage.
Verify that only authorized users can access comments and session data.	Check access control.

Validate Feedback KPIs & Measures

Feedback submitted through the User Feedback Popup is captured by the preconfigured User Feedback KPI.

KPI	Data Model	Description
User Feedback	`UxEvent`	Positive or negative feedback and any associated comment submitted by a user.

The User Session Replay KPI also provides session-level feedback measures:

Measure	Description
Positive Feedback Count	Total number of positive feedback submissions during the session.
Negative Feedback Count	Total number of negative feedback submissions during the session.
Feedback Comment Count	Total number of feedback comments submitted during the session.

Use these measures to verify the configuration and identify sessions containing feedback.

API Integration

GermainUX APIs can process feedback submitted through the User Feedback Popup and use it within custom analytics and automation workflows. API-based processing can be used to:

Create automated insights
Trigger real-time alerts and notifications
Prioritize negative experiences
Initiate follow-up workflows
Create custom transactions
Enrich feedback analysis with user and session context

For example:

Negative FeedbackProcess FeedbackAnalyze User & Session ContextPrioritizeTrigger Follow-Up

This allows feedback to become an operational signal rather than simply a response stored for later review.

Automate Actions from Feedback

Feedback can be incorporated into workflows that:

Notify a support, product, or operations team.
Create or update a ticket.
Trigger additional analysis.
Route feedback according to application, category, user population, or other available context.
Initiate a follow-up workflow.
Generate a custom transaction for additional analysis or reporting.

The exact workflow can be customized according to the organization’s requirements.

User Monitoring and Session Replay APIs

Use the User Monitoring and Session Replay APIs for applicable API operations involving User Feedback and its associated monitoring context. Refer to the User Monitoring and Session Replay API documentation for available API operations.

Analyze Submitted Feedback

After deployment, submitted feedback can be investigated using GermainUX Analytics. Use the User Feedback KPI to review feedback by application, page or screen, and user, and open the associated Session Replay to see what the user experienced when the feedback was submitted.

Troubleshooting

Feedback Does Not Appear

Verify that:

User Feedback is enabled in the applicable Monitoring Profile.
The Real User Monitoring component is active and sending data.
The correct application and environment are being analyzed.
The selected time range includes the test feedback.
The feedback is associated with the expected monitored session.

Session Replay Is Not Available

Verify that:

Session Replay is enabled.
The application and user are included in the Session Replay configuration.
The session occurred within the selected time range.
Privacy or exclusion settings did not prevent the expected data from being captured.

Security & Privacy

Feedback comments and Session Replay may contain personal or sensitive information. Before production rollout:

Configure appropriate masking and exclusion rules.
Limit access to authorized roles.
Confirm applicable consent requirements.
Avoid collecting unnecessary personal information.
Apply appropriate data-retention policies.
Protect API credentials and integrations.
Limit sensitive information sent through alerts or external systems.
Test feedback alerts and integrations to ensure they do not expose sensitive content.

If an email address or other identifying information is collected, verify that it is necessary for the intended feedback workflow and handled according to your organization’s privacy requirements. User Feedback GermainUX RUM JS GermainUX RUM Extension GermainUX RUM Windows User Session Monitoring & Replay Analytics Automation Data Retention

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

Deploy

Configure

Analyze

Troubleshoot

​Overview

​Before You Begin

​Choose a Deployment Method

​Deploy User Feedback

​RUM JS

​RUM Extension

​RUM Windows

​Configure the User Feedback Popup

​Enable the Popup

​Disable the Popup

​Customize the Feedback Popup

​Advanced Configuration Reference

​FeedbackSettings

​FeedbackSettings Properties

​FeedbackButton

​FeedbackButton Properties

​Popup Position

​Comment Configuration

​Comment Styles

​Parent Element

​Validate the Deployment

​Validate Feedback KPIs & Measures

​API Integration

​Automate Actions from Feedback

​User Monitoring and Session Replay APIs

​Analyze Submitted Feedback

​Troubleshooting

​Feedback Does Not Appear

​Session Replay Is Not Available

​Security & Privacy

​Related Documentation

​Get Help