Deploy Monitoring for Drupal

Deploy Monitoring for Drupal

Use the Drupal wizard in GermainUX to create a User Monitoring Profile and generate the RUM JS deployment instructions for the Drupal application.

Additional GermainUX components can be deployed for deeper JavaScript diagnostics, server and database monitoring, logs, integrations, synthetic transactions, and automation.

Deployment options

Deploy only the components required for the desired monitoring depth.

Prerequisites

Before deployment, confirm:

• The Drupal application name and production URL.

• The Drupal environments that should be monitored.

• Access to GermainUX Workspace.

• Permission to update the Drupal theme or another approved script-deployment mechanism.

• The applicable Content Security Policy requirements.

• Network access from user browsers to GermainUX.

• Consent, masking, exclusion, and retention requirements.

• Test access to the Drupal application.

• Access to servers, logs, databases, and APIs when Engine monitoring is required.

• Approval for browser extensions when the RUM Extension or JS Profiler will be deployed.

Choose the browser deployment method

The Drupal wizard provides the appropriate generated script and instructions for the selected deployment method.

Run the Drupal wizard

1. Sign in to Germain Workspace.

2. Open the left navigation menu.

3. Select Wizards.

4. Select Drupal.
   

   

5. Enter the application name.

6. Enter the Drupal application URL.
   

   

7. Select the applicable environment.

8. Configure the initial privacy settings.

9. Review the generated User Monitoring Profile.
   

   

10. Select the preferred deployment method.

11. Complete the wizard.

12. Copy or download the generated deployment instructions.

Use the exact script URLs, profile names, and configuration generated for the target GermainUX environment.

Deploy RUM JS through a Drupal theme

Use a custom or child theme rather than modifying Drupal core or a contributed base theme directly.

Add the generated GermainUX script

Add the script generated by the Drupal wizard to the active theme using the organization’s approved Drupal asset or template mechanism.

The script must:

• Load on every Drupal page included in the monitoring scope.

• Load early enough to capture the required page activity.

• Use the exact URL and profile information generated by GermainUX.

• Load only in approved environments.

• Respect the organization’s consent requirements.

Do not copy a script from another application or GermainUX environment.

Use Drupal libraries when appropriate

For a maintainable theme deployment, add the generated GermainUX asset through the theme’s Drupal library configuration and attach it globally or only to the required routes.

The exact implementation depends on:

• Drupal version.

• Theme architecture.

• Whether the script is hosted locally or remotely.

• JavaScript aggregation.

• Consent-management requirements.

• Environment-specific configuration.

Confirm that Drupal does not aggregate, defer, rewrite, or relocate the script in a way that prevents monitoring from initializing correctly.

Clear Drupal caches

After updating the theme or library:

• Clear the Drupal application cache.

• Clear theme and render caches.

• Rebuild caches using the approved administrative or Drush procedure.

• Purge CDN or reverse-proxy caches when applicable.

• Open a new browser session for validation.

When Drush is available, the standard cache-rebuild command is:

drush cr

Run administrative commands only through the organization’s approved Drupal deployment process.

Deploy a remote script tag

Use this method when Drupal pages can load the monitoring script directly from the GermainUX environment.

1. Select Remote Script Tag in the Drupal wizard.

2. Copy the complete generated tag.

3. Add it through the approved Drupal theme, template, module, or tag-management mechanism.

4. Ensure it appears on every intended page.

5. Update the Content Security Policy when required.

6. Clear Drupal and CDN caches.

7. Validate that the script loads without browser errors.

The browser must be able to reach the GermainUX script and ingestion endpoints over HTTPS.

Deploy a local script tag

Use local hosting when organizational policy requires the RUM JS loader or related assets to be served from the Drupal environment.

1. Select Local Script Tag in the wizard.

2. Download the generated or referenced GermainUX files.

3. Store them in an approved Drupal theme, module, or static-asset location.

4. Preserve the required filenames and paths.

5. Add the generated local script tag.

6. Confirm that the files are included in the application deployment process.

7. Define how GermainUX files will be updated during upgrades.

8. Clear application and CDN caches.

9. Verify the loaded file version.

Local hosting does not eliminate the need for the browser to send monitoring data to the approved GermainUX ingestion endpoint.

Deploy the JavaScript snippet

Use the generated JavaScript snippet when an approved Drupal module, tag manager, template, or custom integration manages script deployment.

Confirm that the mechanism:

• Executes on every intended page.

• Does not run more than once per page.

• Preserves the generated GermainUX configuration.

• Executes after consent when consent is required.

• Does not block page rendering.

• Is deployed consistently across Drupal environments.

Avoid deploying both a script tag and the same snippet on the same page.

Deploy the RUM Extension

Use the GermainUX RUM Extension when direct RUM JS deployment is unavailable or the browser application requires extension-based monitoring.

1. Create or select the Drupal User Monitoring Profile.

2. Deploy the extension through the approved enterprise browser-management system.

3. Configure the GermainUX Enterprise URL.

4. Add the Drupal URL or origin to the monitoring scope.

5. Associate it with the correct application and profile.

6. Configure managed permissions.

7. Refresh or restart the browser.

8. Validate monitoring with an authorized test user.

The RUM Extension monitors only browsers to which it has been deployed. It is generally appropriate for managed employee populations rather than anonymous public visitors.

Do not deploy RUM JS and the RUM Extension to the same users without confirming that the configuration prevents duplicate monitoring.

Configure Content Security Policy

Drupal or its hosting platform may enforce a Content Security Policy.

Allow only the GermainUX origins and directives required by the generated deployment.

Depending on the deployment, this may include:

• script-src

• connect-src

• img-src

• style-src

• worker-src

• frame-src

Use the exact GermainUX hostname and HTTPS scheme. Do not add broad sources such as * or 'unsafe-eval' unless they are independently required, reviewed, and approved.

Validate the policy through browser developer tools and the organization’s security review process.

Configure consent and privacy

Before production deployment, configure:

• Consent requirements.

• Session Replay enablement.

• Text-input masking.

• Password-field exclusion.

• Sensitive element masking.

• Page and route exclusions.

• User and bot exclusions.

• Query-string collection.

• Network request and response collection.

• Data retention.

• Access to user-session evidence.

Drupal forms may contain authentication, contact, health, payment, or other sensitive information. Test masking on every critical form.

Configure application metadata

GermainUX can associate approved Drupal metadata with browser data, including:

• User identifier.

• User role.

• Drupal session identifier.

• Content type.

• Page category.

• Application version.

• Environment.

• Tenant or site.

• Drupal Commerce order or cart context when appropriate.

Use Metadata Extractors only when the required information is not already available.

Do not extract passwords, authentication cookies, tokens, secrets, or unnecessary personal information.

Retrieve installation instructions later

The wizard’s deployment instructions remain available after the profile is created:

1. Go to Germain Workspace > Analytics > UX Monitoring Profiles.

2. Select the Drupal profile.

3. Open the Configuration Editor.

4. Select Installation.

5. Review the generated deployment options and instructions.

Deploy the JS Profiler

Deploy the GermainUX JS Profiler when RUM identifies a problem that requires deeper browser or JavaScript evidence.

1. Confirm that Drupal RUM data is collected correctly.

2. Define the users, pages, or URLs to profile.

3. Deploy the JS Profiler extension through the approved browser-management system.

4. Configure the Drupal application scope.

5. Reproduce or wait for the problem.

6. Verify that profiler data is associated with the correct application and user session.

7. Disable unnecessary deep profiling after sufficient evidence has been collected.

The JS Profiler can capture detailed JavaScript, DOM, network, and browser information. Limit its scope and review privacy requirements before production use.

Deploy the GermainUX Engine

Deploy the GermainUX Engine when monitoring is required beyond the browser.

The Engine can monitor approved:

• Drupal REST APIs.

• Website and service availability.

• Drupal, PHP, and web-server logs.

• Databases.

• Operating systems and infrastructure.

• Docker or Kubernetes environments.

• External integrations.

• Synthetic scenarios.

• Reports and automation.

Place the Engine where it can reach the required systems and GermainUX Enterprise.

Use dedicated least-privilege credentials for every monitored data source.

Configure Drupal API monitoring

For Drupal APIs:

1. Identify the critical API endpoints.

2. Define the required method, authentication, request, and expected response.

3. Store credentials securely in GermainUX.

4. Configure availability and response-time monitoring.

5. Define expected status codes or response conditions.

6. Configure SLAs and Watches.

7. Validate using controlled API requests.

8. Avoid sending production-changing requests unless explicitly approved.

API monitoring should use the least-privilege access necessary for the test.

Configure Drupal log monitoring

Identify the actual logging destinations used by the Drupal environment, such as:

• Drupal logs.

• PHP logs.

• Web-server access and error logs.

• Container logs.

• Operating-system logs.

• Reverse-proxy or CDN logs.

• Integration logs.

Use File and Log Monitoring to configure the applicable sources, parsers, categories, exclusions, and retention.

Configure database monitoring

Drupal commonly uses MySQL, MariaDB, PostgreSQL, or another supported database.

1. Create the database data source.

2. Create dedicated read-only credentials.

3. Configure availability and performance monitoring.

4. Add approved query monitoring when application-specific data is required.

5. Validate query cost and execution frequency.

6. Configure KPIs and SLAs.

7. Confirm that no sensitive Drupal data is unnecessarily collected.

See SQL Query Monitoring.

Deploy synthetic monitoring

Use the GermainUX RPA Bot Recorder to record critical Drupal scenarios.

1. Install the GermainUX RPA Bot Recorder.

2. Open the Drupal application.

3. Record the approved scenario.

4. Add validations for critical pages and outcomes.

5. Remove sensitive or environment-specific test data.

6. Import the script into GermainUX.

7. Assign it to a GermainUX Engine.

8. Configure the execution schedule and location.

9. Define KPIs, SLAs, and Watches.

10. Run a controlled test.

Example scenarios include:

• Open the Drupal site.

• Search for content.

• Sign in with a test account.

• Submit a controlled form.

• Access an authenticated portal.

• Complete a registration.

• Validate a Drupal Commerce journey in an approved test context.

Use dedicated synthetic accounts and controlled test data.

Validate RUM deployment

After deploying RUM JS or the RUM Extension:

1. Open the Drupal application in a supported browser.

2. Confirm that the GermainUX script or extension is active.

3. Navigate through several Drupal pages.

4. Generate controlled clicks and page transitions.

5. Confirm that browser data appears in GermainUX.

6. Verify the application and User Monitoring Profile.

7. Confirm that sessions and pages are associated correctly.

8. Review a Session Replay when enabled.

9. Test masking and exclusions.

10. Check the browser console for CSP or script-loading errors.

11. Confirm that the application is not monitored twice.

12. Measure page and browser overhead.

Troubleshooting

No RUM data appears

Verify:

• The generated GermainUX script is present.

• The correct User Monitoring Profile is enabled.

• The Drupal URL matches the configured scope.

• The script loads successfully.

• The browser can reach GermainUX.

• CSP allows the required origins.

• Consent has been granted when required.

• Drupal or CDN caching is not serving an older template.

• No JavaScript error prevents initialization.

• Bot or user exclusions do not remove the test session.

The script appears more than once

Check:

• Theme templates.

• Drupal libraries.

• Tag-manager configuration.

• Custom modules.

• RUM Extension deployment.

• Cached versions of the page.

Remove the duplicate deployment and confirm that monitoring initializes once.

Some Drupal pages are missing

Verify that:

• The script is attached globally or to every intended route.

• Alternate themes include the script.

• Authenticated and anonymous pages use the expected templates.

• Administrative pages are included or intentionally excluded.

• Cached and uncached page variants include the script.

• Embedded or decoupled front ends are monitored separately.

Session Replay is unavailable

Verify that:

• Session Replay is enabled in the User Monitoring Profile.

• Consent requirements have been satisfied.

• The page is not excluded.

• Privacy configuration does not suppress the entire page.

• The browser supports the required monitoring behavior.

• Session Replay data reaches GermainUX.

Browser monitoring affects performance

Verify that:

• The script is not loaded twice.

• Verbose console or network-body collection has not been unnecessarily enabled.

• JS Profiler scope is limited.

• Session Replay settings are appropriate.

• Custom processors and extractors are lightweight.

• Monitoring and replay overhead remains within the approved level.

Deployment and configuration

ℹ️ Get Help

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