Benefits

Germain's V3 records User's Behavior with a millisecond precision. Critical Insights are automatically identified. Business Impact is reported at scale. All Metadata and Business Data is 100% searchable. Sensitive Data is secured as per GDPR requirements (e.g. data exclusion, anonymization, etc). 

Important note: This V3 has a millisecond granularity (V2 had a second granularity and precision)

Real User Experience

Monitor Real User Experience (click, mouse move, scrolling, typing, etc) of any web application

Replay User Session

Record Videos of Real User Sessions (videos that look like what you would see if you were sitting behind all monitored users) . Then whenever you need, replay these User Sessions Videos (anytime, as long as the session isn't purged which is configurable)

Quantitative and Qualitative metrics

Get complete set of Quantitative insights (scroll down), plus get real User Feedback delivered right when they feel the pain.

Behavior Insights

Get Behavior insight at scale (flow graph driven by user journey or click) and on each Session Replay (confusion, rage, etc)

Workflow/Process Insights

Get Process insight at scale (flow graph driven by business operation milestone) and on each Session Replay (confusion, rage, etc) (Inefficiency, drop-off, etc)

Technology Insights

End-2-end root-cause analysis customized for your infrastructure and tech stacks, including User Error, Browser freeze, Network connectivity issue, Integration failure, etc

100% Searchable

Metadata and Business Data are fully searchable. This is a must to help identify business impact at scale, dive into a critical problem, etc.

Business Impact @ Scale

Why waste time and resources solving minor UX issues when Germain's Aggregate dashboard can help you identify what has the biggest impact on your business? With Germain, you can assess critical issues at scale and dive into each insight, all the way down to a Session Replay. Don't let your team watch thousands of session replays without finding the true source of your UX problems. Choose Germain's Aggregate dashboard for a comprehensive understanding of your business impact.

Customizable Aggregated dashboard can help you assess Business Impact @ scale. Example:

And more benefits with automation

- And in addition to the above real/reactive user experience monitoring, a reminder that you can also 1)proactively detect (synthetic user click) 2)deep dive within your workflows (end-2-end, across your data sources) 3)deep dive within your technologies (code-level analytics, and other) 4)send out alert and recommendations 5)and/or resolve issues via our automation framework



Notes

Germain can also

  1. Monitor other user-related metrics by analyzing the Web Server or Application log files that are created by the Application.

  2. Simulate end-user experience (i.e Synthetic Transaction via an integration to Selenium. Germain makes it also easy to record Selenium script via this Germain extension: Deploy Germain Browser Extension (Synthetic Click Recorder))

KPIs

List of pre-configured KPIs that are available in Germain out-of-the-box. As for anything else, you can also create your own KPI.

Requirement: Germain’s JS or Browser Extension has to be deployed/enabled for these KPIs to produce data.

KPI Name

UX level

Technology level

Core Web Vital

KPI Description

Browser Event

x

x

Custom browser event.

Browser Metric

 

x

Custom browser metric.

Browser Report

 

x

Browser report event (csp violation, feature policy violation, deprecated feature usage, occurence of crash).

Browser Transaction

x

x

Custom browser transaction.

Browser Visibility

 

x

Event of a browser or page being active, inactive, visible, hidden.

Cumulative Layout Shift (CLS)

x

x

x

Cumulative Layout Shift (CLS) measures visual stability as it quantifies how often users experience unexpected layout shifts. Collected data is accessible on Germain RCA Dashboard for a User Click transaction, on the Detail Execution Flow.

First Input Duration

x

x

x

First Input Delay (FID) measures load responsiveness as it quantifies the experience users feel when trying to interact with unresponsive pages. Collected data is accessible on Germain Dashboard by querying User Click KPI as one of its duration.

JavaScript Console Event

 

x

JavaScript console event (e.g. Angular, React, Siebel eScript, etc)

JavaScript Heap Usage

 

x

JavaScript heap size usage in %. Supported currently only on Google Chrome browser.

JavaScript Heap Used Size

 

x

The amount of JavaScript heap memory (in Mbytes) currently being used. Supported currently only on Google Chrome browser.

JavaScript Long Task

 

x

Any uninterrupted period where the main UI thread is busy for 50 ms or longer.

JavaScript Popup Dialog

 

x

JavaScript popup dialog event (alert, prompt, confirm).

Mouse Click

 

x

Event of a mouse click or user touch.

Outbound CSS Request

 

x

Outbound CSS request transaction (in seconds).

Outbound Document Request

 

x

Full page render duration (in seconds; time from first byte to load in seconds).

Outbound HTTP Request

 

x

Outbound HTTP request transaction (in seconds).

Outbound Image Request

 

x

Outbound Image request transaction (in seconds).

Outbound Resource Request

 

x

Outbound Resource request transaction (in seconds).

Outbound Script Request

 

x

Outbound Script request transaction (in seconds).

Page Largest Paint
a.k.a. “Largest Contentful Paint (LCP)”

 

x

x

Largest Contentful Paint (LCP) measures perceived load speed as it marks when the page's main content (image or text block) visible within the viewport has likely loaded. Collected data is accessible on Germain Dashboard by querying Page Largest Paint KPI.

Page Memory

 

x

The amount of memory (in Mbytes) used by the page. Supported only in latest browsers.

Page Performance Measure

 

x

Custom performance measurement in JavaScript code.

Rage Click

x

x

Event of a rage user click (multiple consecutive click on the same element).

Unhandled Promise Rejection

 

x

Event that occurs when a promise is rejected and no handler is present.

User Change

x

 

Event of a end-user changing a value (input, select).

User Click

x

 

Cumulative transaction duration of all requests and events between 2 consecutive clicks (in seconds). It will contain async and sync transactions.

User Feedback

x

 

Feedback provided by a user (thumbs up/down and user’s comment).

User Key Press

x

 

Event of key pressed by a user.

User Replay

Replay of Real User Session

User Session Replay Segment

x

 

Individual intervals of User Session Replay activity.

WebSocket Connection Event

 

x

WebSocket connection event (closed or opened).

WebSocket Error

 

x

WebSocket error.

WebSocket Message Size

 

x

WebSocket message size (in bytes; message received or sent size).

WebSocket Session

 

x

WebSocket session duration (in seconds; between opened and closed).

Activity/Inactivity

Activity Duration

The active time that a user spend on the monitored app

Inactivity duration

The idle time that a user spends not using the monitored app

Business Process (Name/Step/Confusion)

Business function/operations can be monitored by Germain, and across Data Sources (e.g. KYC/Know Your Customer process may involve the monitoring of an end client visiting your Website, calling your Sales Center, visiting your physical Office or Store, etc).

So here, whenever a User (that is being monitored by Germain while that User navigates your web app) performs a series of clicks that relate to a Business Process (that is configured in Germain and being monitored as a result), that instance of a BP will show up on the recorded User Session Replay Video as indicated below by this icon:

As a result, that feature will help you identify when the user is going off chart and confused on how to perform his/her task.

Important: This page here only covers the portion of a Business Process that refers to a User browsing a web app (website, ercommerce, crm, etc). But again, a BP can be monitored beyond just the navigation on a web app. Details on how to configure a Business Process

Browser Event/Metric/Transaction

Custom events if configured

Browser Report

Csp violation, feature policy violation, deprecated feature usage

Core Web Vitals

Germain collects all Core Web Vitals metrics to boost your website performance and improve user experience.

Largest Contentful Paint (LCP)

LCP measures perceived load speed as it marks when the page's main content (image or text block) visible within the viewport has likely loaded. Collected data is accessible on Germain Dashboard by querying Page Largest Paint KPI.

First Input Delay (FID)

First Input Delay (FID) measures load responsiveness as it quantifies the experience users feel when trying to interact with unresponsive pages. Collected data is accessible on Germain Dashboard by querying User Click KPI as one of its duration.

Cumulative Layout Shift (CLS)

Cumulative Layout Shift (CLS) measures visual stability as it quantifies how often users experience unexpected layout shifts. Collected data is accessible on Germain RCA Dashboard for a User Click transaction, on the Detail Execution Flow.

Feature available in Germain v2022.2 or later

Error

Any error that occurred on a browser

Geo Location

By default, all Germain UX data coming from any standard web application (e.g. Salesforce, SugarCRM, Siebel, SAP) will be geographically located using the user desktop's IP address.

Example of geo location data presented on a portlet map.

JavaScript Console Monitoring

Germain collects JavaScript console events such as warnings and errors. By default this monitoring is enabled and only errors are collected.
Collected events are accessible on Germain Dashboard by querying JavaScript Console Event KPI.

Examples

Below data points available on Germain collected by JavaScript Monitoring.

JavaScript Long Task

Any uninterrupted period where the main UI thread is busy for 1s or longer.

Page Largest Paint

Represents largest image or text paint before user input on a web page. The timing of this paint is a good heuristic for when the main page content is available during load)

Page Memory

The amount of memory (in Mbytes) used by page. Supported only in latest browsers and with special response header set; this is much better granularity then the existing "JavaScript Heap Usage" which is for the entire browser and the new one is just for the particular window/page)

Rage Click

The user of the monitored app clicking several time on the same UI element, possibly indicating a technology issue.

SEO Campaign

Germain collects Search Engine Optimization (SEO) Campaign data from the monitored website. Extracted information will be stored on each UX data point and will be available on Campaign Dimension as on the image below.

Google Analytics UTM

Default campaign extractor is available and collects data from:

  1. Google Analytics UTM parameters from page query string

  2. Google Analytics UTM parameters from __utmz cookie


Privacy (GDPR, PCI)

Like any other data that is collected by Germain, you have full control over the data that is collected by Germain 's JS or browser extension. You decide what data is collected, which one is not collected, whether that data is encrypted or anonymized. Many security constraints are preconfigured by us (to make your life easier), yet all this is configurable by you, would you have different security constraints.

Data Privacy (GDPR, PCI)

Users & Roles

Visibility - Dashboard Visibility, Team, Owners - Germain UX

User Exclusion

You can disable User Experience Monitoring for selected named users. Use this feature if you don’t want UX monitoring data from your automated or synthetic users.

Note: Germain UX script will be deployed for all the users as it needs to extract the username first, but the monitoring will not start if the extracted user belongs to the Excluded Usernames list.

Bot/Crawler Agent Exclusion (Googlebot, Yandex bot, etc)

You can disable User Experience Monitoring for selected user agents. Use this feature if you don’t want UX monitoring data from particular bots, crawlers or end users' browsers.

By default we exclude the following bots:

  • Baiduspider

  • Bingbot

  • DuckDuckBot

  • Exabot

  • facebot and facebookexternalhit

  • Googlebot

  • ia_archiver

  • Sogou

  • Slurp

  • YandexBot

IP Blacklist / Whitelist

Enable or disable User Experience Monitoring for selected IPs or IP ranges. Use blacklist feature if you don’t want UX monitoring data, e.g. from your automated or synthetic users. Use include feature if you want UX monitoring data only from certain desktops/users (whitelist settings will override blacklist settings). By default blacklist and whitelist are empty. Empty whitelist means that UX monitoring is enabled for all IP addresses.

You can provide either a single IP or a comma separated start IP and end IP.

Setup

Dynamically enabled, Germain’s Real User Monitoring can occur via 2 options: 1) inject Germain Javascript into your web app 2) or deploy Germain Browser Extension (for application that don’t allow javascript injection)

Feature available in Germain v2022.3 or later

Blacklist IP:

  1. Go to Analytics > UX Monitoring Profiles

  2. Select a UX Monitoring Profile

  3. Add new IP exclusion under Excluded IP Ranges

Whitelist IP:

  1. Go to Analytics > UX Monitoring Profiles

  2. Select a UX Monitoring Profile

  3. Add new IP exclusion under Included IP Ranges

The following example shows one excluded IP (10.0.1.1) and one included IP range (all IP addresses between 192.168.0.0 and 192.168.255.255 including start and end will be included).

Feature available in Germain v2022.3 or later

Bot/Crawler Agent Exclusion

You can enable/disable Bot/Crawler Agent Exclusion when deploying Germain UX monitoring for the first time:

To update Bot/Crawler Agent Exclusion list:

  1. Go to Analytics > UX Monitoring Profiles

  2. Select a UX Monitoring Profile

  3. Add/Modify/Remove user agent under Excluded User Agents

The following example shows all default excluded user agents.

Custom extractor (SEO Campaign)

function can be provided via settings.application.campaignExtractor.

The following code sample shows how to write a custom campaignExtractor to collect Urchin Tracking Module (UTM) parameters from page query string:

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);
...
settings.application.campaignExtractor = function() {
    var queryString = window.location.search;
    if (queryString) {
        var values = germainApm.utils.parseQueryStringToMap(queryString); // internal function to convert query string into a map
        if (values['utm_medium'] && values['utm_source']) { // required fields
            return {
                source: values['utm_source'] || null,
                medium: values['utm_medium'] || null,
                content: values['utm_content'] || null,
                name: values['utm_campaign'] || null,
                term: values['utm_term'] || null
            };
        }
    }
    return undefined;
};
...
germainApm.start(settings);
CODE

Deploy Germain Javascript

Deploy Germain Browser Extension

Feature available in Germain v2022.2 or later

JavaScript Console Monitoring

Disable

To disable JavaScript Console Monitoring don’t provide any method in the plugin configuration. The following code sample how to disable this monitoring.

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);
...
settings.plugins.console.methods = [];
...
germainApm.start(settings);
JS
Configure

The following configuration settings are available.

/** JavaScript console monitoring settings. */
console: {
    /** Maximum length that we will collect from the console output object. Default: 1024.*/
    maxLogStringLength: number;
    /** Console methods to monitor. Default: ['error']. */
    methods: ('assert' | 'clear' | 'count' | 'countReset' | 'debug' | 'dir' | 'dirxml' | 'error' | 'group' | 'groupCollapsed' | 'groupEnd' | 'info' | 'log' | 'table' | 'time' | 'timeEnd' | 'timeLog' | 'timeStamp' | 'trace' | 'warn')[]
}
JS

The following code sample shows how to monitor console info, warning and error events. In addition we limit the console output to 100 characters.

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);
...
settings.plugins.console = {
    methods: ['info','warn','error'],
    maxLogStringLength: 100
};
...
germainApm.start(settings);
JS

Feature available in Germain v2022.2 or later

Metadata Extractors

Germain extracts and collects your application’s Metadata such as username or sessionId.

Metadata extractor has to be configured in the Germain UX Init script. Custom function which follows the below definition has to be added to the settings.application.metadataProviders object tto extract a metadata content. It can return one of the following: value, promise, null or undefined. Undefined value won't override previously extracted value (e.g. on a different tab), but null will.

type MetadataProviderFunction = (window: Window) => undefined | null | string | Promise<undefined | null | string>;
JS

window Current window.

Below example shows a custom sessionId metadata extractor where getSessionId function contains the logic to return application’s internal session id.

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);
...
settings.application.metadataProviders['sessionId'] = getSessionId;
...
function getSessionId(window) {
   ...
   return 'sessionIdValue';
}
...
germainApm.start(settings);
CODE

As frequently username or sessionId is not available on the page when Germain UX starts, we have a mechanism to wait for metadata values before we start sending UX data points which might be incomplete. Wait mechanism is configurable via settings.constants.metadataTimeoutMillis treshold and by default it is set to 15 seconds. Please note that we will wait for all configured metadata providers to resolve and not just for the first one that returns a value. Below example shows how to extend metadataTimeoutMillis to 20 seconds.

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);
...
settings.constants.metadataTimeoutMillis = 20 * 1000; // value must be provided in ms
...
germainApm.start(settings);
CODE
Username Extractor

One of the most common use case to define a metadata extractor is to collect your users' names available somewhere in your application.
Below example shows a username metadata extractor which looks for the logged username available on the page under a div element with username id.

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);
...
settings.application.metadataProviders['user.name'] = (window) => {
    return new Promise(resolve => { // return a Promise which will return a value
        germainApm.utils.waitForElements(window, '#username', elements => { // use our utiliy function to wait for all elements available on window with a selector on the '#username'
            const el = elements[0];
            resolve(el.innerText || null); // return div's content meaning the username that we are looking for or null
        });
    });
}; 
...
germainApm.start(settings);
CODE

SessionId Extractor

Another frequent use case to define a metadata extractor is to collect your internal session ids.
Below example shows a sessionId metadata extractor which looks for the sessionId value inside a cookie called SESSION.

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);
...
settings.application.metadataProviders['sessionId'] = (window) => {
    return new Promise(resolve => { // return a Promise which will return a value
        if(document.cookie && document.cookie.indexOf('SESSION') > -1){
            const cookieItems = decodeURIComponent(document.cookie).split(';');
            for (let i = 0; i < cookieItems.length; i++) {
                if (cookieItems[i].trim().indexOf('SESSION') === 0) {
                    resolve(cookieItems[i].trim().split("=")[1]);
                }
            }
        }
        reject(null);
    });
}; 
...
germainApm.start(settings);
CODE

Recording Length

You can now configure Germain so the Real User Replay gets only recorded for a fix length e.g. 1 hour

Germain RUM Ext/JS’s InitScript parameter to configure:

settings.constants.staleSessionTimeoutMillis = 1 * HOURS;
CODE
settings.constants.idleSessionTimeoutMillis = 8 * HOURS;
CODE
settings.constants.maxSessionDuration = 24 * HOURS;
CODE

Note: if these 3 parameters are not available, you can add them on starting with Germain 2022.5

Start/Stop/Uninstall

The Germain UX Client API allows developers to start, stop or uninstall the injected monitoring (Germain’s JS or browser extension) directly via JavaScript.

Start Monitoring

Germain UX Monitoring starts automatically once germainapm.js script, injected on the monitored website, has been downloaded and loaded therefore it doesn't need to be called in normal scenario. However, if Germain UX Monitoring has been stopped via germainApm.stop() call, it can be started by calling this method.

germainApm.start(settings: MonitoringSettings, onAllTabs?: boolean) => void;
JS

settings Monitoring settings.

[onAllTabs] If true, start monitoring on all opened tabs only if BroadcastChannel is supported by your browser. If false, start monitoring only on the active tab. Default: false.

Stop Monitoring

Stop Germain UX Monitoring. It uninstalls all monitoring instrumentation but it doesn’t remove germainApm code from the monitored page. It stops the monitoring immediately and it doesn't trigger any data flush at that point. Monitoring will restart on the next full page load (server side load must occur, e.g. hard page navigation or full page refresh via F5).

germainApm.stop(onAllTabs?: boolean) => void;
JS

[onAllTabs] If true, stop monitoring on all monitored tabs only if BroadcastChannel is supported by your browser. If false, stop monitoring only on the active tab and keep it active on other tabs. Default: true.

Uninstall Monitoring

Stop Germain UX Monitoring, flush all data available in browser’s cache and, optionally, remove any available state. Internally it makes a call to germainApm.stop(onAllTabs). Custom logout event generator should call germainApm.uninstall(true, true). Monitoring will restart on the next full page load (server side load must occur, e.g. hard page navigation or full page refresh via F5).

germainApm.uninstall(clearSessionState?: boolean, onAllTabs?: boolean) => void;
JS

[clearSessionState] If true, clears also monitoring state from the browser’s storage and removes the entire monitoring metadata. If false, keeps monitoring state in browser’s storage. Default: false.

[onAllTabs] If true, stop monitoring on all monitored tabs only if BroadcastChannel is supported by your browser. If false, stop monitoring only on the active tab and keep it active on other tabs. Default: false.

User Exclusion

  1. Go to Analytics > UX Monitoring Profiles

  2. Select a UX Monitoring Profile

  3. Add new username under Excluded Usernames

The following example shows 3 users who are going to be excluded from the UX monitoring.

User Feedback

Enable this feature in Germain UX Init script by setting settings.plugins.feedback.enabled to true. The following code sample shows how it can be enabled.

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);
...
settings.plugins.feedback.enabled = true;
...
germainApm.start(settings);
JS
Disable

By default User Feedback feature is disabled and configuration is not required. The following code sample however shows how it can be explicitly disabled.

const settings = germainApm.getDefaultSettings(loaderArgs, agentConfig);
...
settings.plugins.feedback.enabled = false;
...
germainApm.start(settings);
JS
Configure

The following configuration settings are available.

/** User feedback settings. */
feedback: {
    /** Enable user feedback buttons if se to true. Default: false. */
    enabled?: boolean;
    /** Positive button settings. Default: icon: Default thumbs up icon, label: "Send positive feedback for this page", backgroundColor: '#22d249', parentSelector: document.body. */
    positive?: FeedbackButton;
    /** Negative button settings. Default: icon: Default thumbs up icon, label: "Send negative feedback for this page", backgroundColor: '#e10421', parentSelector: document.body. */
    negative?: FeedbackButton;
    /** Button absolute position. Default: 'bottom-left'. */
    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
    /** Comment settings */
    comment?: {
        /** Comment position relative to positive/negative button. Default: 'right'. */
        position?: 'left' | 'right';
        /** Hint displayed for comment. Default: 'Tell us more'. */
        commentHint?: string;
        /** Hint displayed for email. Default: 'Email'. */
        emailHint?: string;
        /** Hint displayed for send button. Default: 'Send'. */
        sendHint?: string;
        /** Additional styles attribute/value that will get applied to the comment elements. */
        styles?: Record<'container' | 'email' | 'comment' | 'send' | 'close', Record<string, string>>;
    }
}
...
type FeedbackButton = {
    /** Image as data:image URI. */
    icon?: string;
    /** Button title that will show up on mouse over. */
    label?: string;
    /** Button background */
    backgroundColor?: string;
    /** Parent element to which this button will be appended. Default (if not provided): document.body */
    parentSelector?: string;
    /** Additional styles attribute/value that will get applied to this button. */
    styles?: Record<string, string>;
};
JS

The following code sample shows how to enable this feature with custom look and feel and 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);
JS

Feature available in Germain v2022.3 or later

Customize

The Germain UX Client API allows developers to generate custom data points via JavaScript API. or in other words you can create your own UX Event, Log, Metric and/or Transaction

Create Event

Create custom UX event data point.

germainApm.api.createEvent(name: string, details?: Record<string, any>) => void;
JS

name An event name.

[details] An optional JavaScript object containing additional information about this event.


Create Metric

Create custom UX metric data point with a numeric value.

germainApm.api.createMetric(name: string, value: number, details?: Record<string, any>) => void;
JS

name A metric name.

value A metric numeric value.

[details] An optional JavaScript object containing additional information about this metric.


Create Transaction

Create custom UX transaction data point with a duration. There are two ways of creating a transaction, either duration is known and provided at the moment of creating a data point or duration is not known and has to be calculated between start and end markers.

Provided Duration
germainApm.api.createTransaction(name: string, duration: number, details?: Record<string, any>) => void;
JS

name A transaction name.

duration A transaction duration. To keep consistent with other transactions, use seconds as unit.

[details] An optional JavaScript object containing additional information about this transaction.

The following code sample shows how to use the createTransaction method.

const txnStart = Date.now();
...
const txnDuration = Date.now() - txnStart;
germainApm.api.createTransaction('login-txn', txnDuration);
JS
Calculated Duration

Start transaction marker.

germainApm.api.startTransaction(name: string, details?: Record<string, any>) => void;
JS

name A transaction unique name. It will identify this transaction and must be used to close it.

[details] An optional JavaScript object containing additional information about this transaction.

End transaction marker.

germainApm.api.endTransaction(name: string, details?: Record<string, any>) => void;
JS

name A transaction name to close. Must be one of the transaction name that has been started beforehand.

[details] An optional JavaScript object containing additional information about this transaction.

The following code sample shows how to create a transaction using startTransaction and endTransaction methods.

germainApm.api.startTransaction('login-txn');
...
germainApm.api.endTransaction('login-txn');
JS


Create Log

Create custom internal monitoring log event. Logs can be accessed by calling germainApm.rootWindow.state.debugLog on the monitored window.

Configure MonitoringSettings.constants.logLevelToEmitAsFacts and MonitoringSettings.constants.logLevel in your Germain UX init script to collect logs as data points and access them by querying Germain UX agent debug KPI on Germain Dashboard.

germainApm.log(level: 'TRACE'|'INFO'|'WARN'|'ERROR'|'NONE', message: string, obj?: Object) => void;
JS

level Log level type.

message Log main content message.

[details] An optional JavaScript object containing additional information about this log.

The following code sample shows how to create a log in a caught exception.

try {
  ...
} catch(ex) {
  germainApm.log('ERROR', 'My function ABC failed.', ex);
}
JS

The following code sample shows how to create a log with trace information.

germainApm.log('TRACE', 'My trace information', {timestamp: Date.now(), details: 'Additional content'});
JS

KPI list and all configuration examples apply to Germain v2022.2 or later

Dashboard Example