Salesforce Classic, Lightning

Features

Germain is preconfigured to monitor Uptime, Performance and User Experience of Salesforce Cloud applications

Metrics/KPI for Salesforce

Below is a list of pre-configured KPIs in Germain. And you can create your own KPI.

Application KPI

• Apex Callout

• Apex Class

• Apex Code Coverage

• Apex Custom Action

• Apex Execution

• Apex SOAP Event

• Apex Trigger Event

• Apex Unexpected Exception Event

• Api Event (anomaly, etc)

• Api Request

• Async Report Run Event

• Aura Request Event

• Browser Performance Count

• Bulk Api Event

• Bulk Api Result Event

• Classic Record Event

• Code Database Execution

• Code Debug Event

• Code Exception

• Code Execution

• Code SOQL Execution

• Code Unit Execution

• Code Visual Force Execution

• Concurrent Long-running Apex Error Event

• Credential Stuffing Event

• Dashboard Event

• External Custom Apex Callout Event

• External OData Callout Event

• External Service Custom Action

• Flow Coverage

• Flow Custom Action

• Generic Event

• Instance Status

• Lightning Error Event

• Lightning Interaction Event

• Lightning List View Event

• Lightning Page View Event

• Lightning Performance Event

• Lightning Record Event

• Lightning User Session

• Login Event

• Logout Event

• Metadata API Operation Event

• Page Performance Count Event

• Process Approval Event

• Process Rule

• Queued Execution Event

• Record Change Event

• Records Count

• Report Anomaly Event

• Report Execution Event

• Report Export Event

• Resource Usage

• REST API Event

• Search Event

• Session Hijacking Event

• Setup Audit

• URI Event

• Visualforce Request Event

• Wave Change Event

• Wave Interaction Event

• Wave Performance Event

Business Process KPI

• Process Step (e.g. Cases, Opportunities, Accounts, Leads, etc)

• Drop-off

• Process Approvals

• Process Rules

• Process Step/Milestone performance

• Status

• Business Data Change (new record, update, deletion, undelete)

• Business Data Performance (e.g. alert when a Case stays open longer than 30minutes)

User KPI

• Connected users

• CTI (errors, logs, toast messages)

• Login/Logout event

• Page Performance

• Real and Synthetic Users

• Switch To Lightning

• Switch To Classic

• User Behavior

• User Click

• User Errors (OOTB and Custom Errors - app or developer errors e.g. “Sorry or interrupt”, warnings, errors, asserts thrown into browser console by apex, views, developers, …)

• User Feedback

• User Rage

• User Session Replay (example: Replay of a User using Salesforce.com )

• User Type (Classic, Lightning)

Need something else? email us: mailto:support@germainux.com

Examples

Apex Code Analysis

Apex Debug

Apex Unexpected Exception

Apex Unit

Apex Error

(thrown by Browser Console)

Behavior or Process Frictions

CTI Integration

Custom Objects

(e.g. System_Error__c)

Database Execution

Data Update / Delete / Create

Developer Error

Event

Failed HTTP Requests

UI and Backend Correlation

UI Issues / User Errors

UI Issues By Page

JavaScript Console Event

JavaScript Code Analysis

Logs

Metadata Change

Performance

Performance (Browser)

Performance (Page)

Popup Error

Resource Usage

@Switch to Classic

SOQL Execution metric

System Error “Sorry to Interrupt”

Real-time Event metric

User Session Replay

Visual Force metric

Deploy

Integrations

Every data and transaction that Salesforce.com has made available to its Client is available to Germain, as long as the Client authorizes it. Germain integrates with all access points that are offered by Salesforce.com, including:

• Salesforce.com User Interfaces (monitored via Germain RUM Browser Extension)

• Salesforce.com Rest APIs (monitored via Germain Engine)

• SaesForce.com Logs (monitored via Germain Engine)

Requirements

• Salesforce "Lightning Experience" must be enabled

• Salesforce permissions to use "Developer Console" (details here)

• Salesforce domain configured (details here)

• Browser incognito or other private browsing modes are not supported

• Access to "Content Security Policy Trusted Sites" must be enabled

• Germain component must be injected on the default page (usually it is "Home Page")

• Germain component is supported on the following browsers: Google Chrome 48+, latest Microsoft Edge (Chromium based with Chrome Extension install permission enabled) and latest Mozilla Firefox

• JavaScript and cookies must be enabled to run Germain in your browser

• HTTPS outbound traffic must be allowed from your browser(s) to the Germain environment

Deploy Germain RUM Browser Extension

There are two ways of enabling Real User Experience and Session Replay Monitoring for Salesforce.com (Classic or Lightning):

• Deploy Germain RUM Extension to ALL Salesforce.com Users (at once) via Windows Group Policy

• Deploy Germain RUM Extension locally

Configure Germain RUM Browser Extension

Once Germain RUM Extension deployed, you will need to configure it using one of these two options:

• SFDC Lightning Component Configuration (Auto)

• Extension Configuration (Manual)

In addition, CSP Configuration must be done no matter which deployment type you select.

SFDC Lightning Component Configuration (Auto)

Create Germain Component

• Go to Setup > Visualforce Components

• Click on Developer Console

• Create new Lightning Component from the File > New menu:

  • Name: "GermainUXComponent"

  • Content:

<aura:component implements="flexipage:availableForAllPageTypes" access="global">
    <aura:handler name="init" value="{!this}" action="{!c.doInit}" />
    <aura:attribute name="currentUser" type="User" default="{'sObjecttype': 'User'}"/>
    <p class="slds-hide">
        <span id="germain-apm-profile-email">
           {!v.currentUser.Email}
        </span>
        <span id="germain-apm-profile-id">
           {!v.currentUser.Id}
        </span> 
    </p>
    <p aura:id="container" class="slds-hide">
        <lightning:card title="Germain" iconName="custom:custom11">
            <div class="slds-grid slds-grid_vertical slds-align_absolute-center" aura:id="install">
                <div class="slds-button slds-button_brand">
                    <p class="slds-p-around_small slds-text-heading_medium">
                        <lightning:formattedUrl aura:id="extensionUrl" value="" label="Germain" target="_blank" />
                    </p>
                </div>
                <div>
                    <lightning:formattedUrl
                        value="https://docs.germainux.com/main/salesforce-com-monitoring"
                        label="Documentation"
                        target="_blank"
                    />
                </div>
            </div>
        </lightning:card>
    </p>
</aura:component>

• Create new controller for this component (ctrl+shift+2 or click CONTROLLER in the right-hand side menu):

  • Name: "GermainUXComponentController"

  • Content:

({
    doInit: function (component, event, helper) {
        // get user info and set it back for SFDC UI
        component.set("v.currentUser", $A.get("$SObjectType.CurrentUser"));
        // get other info
        var container = component.find('container');
        var extensionUrl = component.find('extensionUrl');
        var browserType = helper.getBrowserType();        
        // check if extension exists
        if (browserType === 'CHROME' || browserType === 'EDGE' || browserType === 'FIREFOX') { // supported browser check
            // function to execute if extension doesnt exist
            var timeout = setTimeout(function () {
                window.postMessage({type: 'germainapm.notInstalled'}, '*'); // for SFDC classic
                $A.util.removeClass(container, 'slds-hide');
                extensionUrl.set('v.value', browserType === 'FIREFOX' ? helper.EXT_IDS.FIREFOX : helper.EXT_IDS.CHROME);
            }, 2000);
            // listen if extension exists
            window.addEventListener('message', function (event) {
                if (event && event.data) {
                    const msg = event.data;
                    if(msg.type === 'germainapm.pong'){
                        clearTimeout(timeout);
                        window.postMessage({type: 'germainapm.install', url: helper.GERMAIN_UX_URL, website: { url: window.location.origin, appName: helper.APP_NAME, profileName: helper.PROFILE_NAME, disableRemove: true}}, '*');
                    } else if(msg.type === 'germainapm.extinstalled'){
                        window.postMessage({type: 'germainapm.install', url: helper.GERMAIN_UX_URL, website: { url: window.location.origin, appName: helper.APP_NAME, profileName: helper.PROFILE_NAME, disableRemove: true}}, '*');
                        $A.util.addClass(container, 'slds-hide');
                    }
                }
            }, true);
            window.postMessage({type: 'germainapm.ping'}, '*');
        }
    }
});

• Create new helper for this component (ctrl+shift+3 or click HELPER in the right-hand side menu):

  • Name: "GermainUXComponentController"

  • Content: 

({
    GERMAIN_UX_URL: 'YOUR_GERMAIN_UX_HOST', //e.g. https://germainux.mydomain.com
    APP_NAME: 'Salesforce',
    PROFILE_NAME: 'Salesforce',
    EXT_IDS: {
        CHROME: 'https://chrome.google.com/webstore/detail/user-monitoring-for-webap/fkcljfeejffnjajnpjflfammljcmdfnh',
        FIREFOX: 'https://addons.mozilla.org/en-US/firefox/addon/user-monitoring-for-webapp/'
    },
    getBrowserType: function () {
        var browser = JSON.parse(JSON.stringify($A.get('$Browser')));
        if (browser.isWEBKIT) {
            return 'CHROME';
        } else if (browser.isFIREFOX) {
            return 'FIREFOX';
        } else {
            var ua = window.navigator.userAgent.toLowerCase();
            if (ua.indexOf('edg') > -1 && ua.indexOf('edge') === -1) {
                return 'EDGE';
            }
        }
        return null;
    },
});

• Replace with your Germain URL (ask Germain Team how to find it if not sure)

• Create new Lightning Application from the File > New menu:

  • Name: "GermainUXApplication"

  • Content: 

<aura:application access="global" extends="ltng:outApp" >
	<aura:dependency resource="YOUR_SALESFORCE_NAMESPACE:GermainUXComponent"/>
</aura:application>

• Replace YOUR_SALESFORCE_NAMESPACE with your unique namespace (details here)

Install Germain Component

• Go to your Home Page or any other default page on your Salesforce environment

• Click Edit Page from the Setup menu

• Add GermainUXComponent, from Lightning Component > Custom menu, to your page somewhere at the top

• Save your changes and activate them (Activate) for all profiles

• Clear your browser cache and refresh your page

• Your page should contain now Germain Component, similar to this:

Extension Configuration (Manual)

If you want to let Salesforce.com users decide to enable/disable Germain as per their liking.

• Open Germain RUM Extension (below an example where you can find it in Chrome browser)

• Set Germain UX URL - this will be the base URL of your Germain instance (ask Germain Team how to find it if not sure)

• Click Add New Website

  • Website URL - this is the base URL of the site you want to monitor (in this case Salesforce instance URL starting with https://)

  • Application Name - set this to the name of the application (e.g. Salesforce)

  • Profile Name - set this to the same value that is set in Germain (e.g. Salesforce)

Once configured, refresh the page. Your application is now ready to be monitored.

CSP Configuration

• Go to Setup > CSP Trusted Sites

• Add the following 4 trusted sites:

Trusted Site Name = GermainUX
Trusted Site URL = Url of your Germain root domain (e.g. https://abc.cloud.germainux.com; ask germain Team how to find it if not sure)
Active = true
Context = All
CSP Directives = Select All
---
Trusted Site Name = SalesforceDomain
Trusted Site URL = Url of your Salesforce domain (e.g. https://mycompanyname.my.salesforce.com; ask germain Team how to find it if not sure)
Active = true
Context = All
CSP Directives = Select All
---
Trusted Site Name = SalesforceLightningDomain
Trusted Site URL = Similar to SalesforceDomain url but replace "my.salesforce.com" by "lightning.force.com" (e.g. https://mycompanyname.lightning.force.com; ask germain Team how to find it if not sure)
Active = true
Context = All
CSP Directives = Select All
---
Trusted Site Name = SalesforceContentDomain
Trusted Site URL = Url of your Salesforce content domain (ask germain Team how to find it)
Active = true
Context = All
CSP Directives = Select All

• Configuration example:

Deploy Germain Engine (Windows or Unix Services)

OAuth App Configuration

OAuth configuration is a required step if you want to deploy Germain Engine to monitor your Salesforce environment.

• Go to Setup

• Go to Apps > App Manager

• Click on New Connected App to create new app

  • Connected App Name: “germainUXOAuth“

  • Contact Email: your email

  • Enable “Enable OAuth Settings”

  • Callback Url: “https://YOUR_GERMAIN_UX_HOST/germainapm/callback”

  • Selected OAuth Scopes: “Full Access (full)”

  • Disable “Require Secret for Web Server Flow”

  • Disable “Require Secret for Refresh Token Flow“

  • Save your changes

For SFDC Data Monitoring

You will need to configure a Germain Engine and use the HTTP/S component. Please contact us for details.

Creating new engine from inside Germain

• Go to “APM State”

• Click on the node where you want to deploy the engine

• Under the “Engines” sub-section, click the add/plus button to add a new engine

• Provide a name for the engine and click next

• You may wish to review or change the Java parameters

• Click Finish to deploy the engine

Deploy REST API Monitor on Germain Engine

• Click the engine you have just created

• Find the “Components” sub-section, click the add/plus button to add a new component

• Select “HTTP Scenario Component Deployment“ from the down-down list

• Fill in the required information -

  • 

    Server - this is the salesforce endpoint

  • Credentials - username and password for REST API

  • Application Name - Salesforce

  • 

    Component Type - select “Salesforce REST API Monitoring”

  • Protocol - change to HTTPS

  • Port - change to 443

  • 

    Provide Monitor Name → Salesforce REST API Monitoring

  • Set a schedule to run every hour at 00 minutes

• Click Finish

This will deploy the Salesforce REST API Monitor and it will begin collecting data

For SFDC Application Monitoring

You will need to configure a Germain Engine and use the HTTP/S component. Please contact us for details.

Creating new engine from inside Germain

• Go to “APM State”

• Click on the node where you want to deploy the engine

• Under the “Engines” sub-section, click the add/plus button to add a new engine

• Provide a name for the engine and click next

• You may wish to review or change the Java parameters

• Click Finish to deploy the engine

Deploy HTTP Log Monitor on Germain Engine

• Click the engine you have just created

• Find the “Components” sub-section, click the add/plus button to add a new component

• Select “HTTP Log Monitor Deployment“ from the down-down list

• Fill in the required information -

• Server - this is the salesforce endpoint

• Credentials - username and password for Salesforce access

• Application Name - Salesforce

• Component Type - select “Salesforce Event Log Monitoring”

• Protocol - change to HTTPS

• Port - change to 443

• Set Login Host to “login.salesforce.com“

• Set path to the location where Salesforce log files(CSV) will be stored

• Click Finish

This will deploy the Salesforce Event Log Monitor and it will begin collecting data

Deploy Log Directory Monitor on Germain Engine

• On the same engine add another component

• Select “Directory Monitor Deployment“ from the down-down list

• Fill in the required information -

  • 

    Component Type - select “Salesforce Log Directory Monitoring” from the drop-down list

  • Path - choose the same path used in the previous component “HTTP Log Monitor“

  • Monitored Server - choose the Salesforce server

  • 

    Set Monitor Name to “Salesforce Directory Monitor”

• Click Finish

Once deployed, this component will start to process all the Salesforce log files

Deploy Log Parser on Germain Engine

• On the same engine add another component

• Select “Parser Deployment“ from the down-down list

• Fill in the required information -

  • 

  • Component Type - select “Salesforce Log Parser” from the drop-down list

  • Monitored Application - Choose Salesforce

  • Click Next

  • 

  • Set Monitor Name to “Salesforce Log Parser”

• Click Finish

This component will start to parse all the Salesforce Log Files

Deploy Germain JS Profiler (Browser Extension)

For SFDC Javascript Analysis

Deploy Germain Mobile (Android App)

For monitoring of Native SFDC Android App Users

Deploy Germain RPA BOT Recorder (Browser Extension)

For SFDC Administrator wanting to detect SFDC issues before SFDC users get to experience them