clarity-js 0.6.26 → 0.6.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-js",
-  "version": "0.6.26",
+  "version": "0.6.30",
   "description": "An analytics library that uses web page interactions to generate aggregated insights",
   "author": "Microsoft Corp.",
   "license": "MIT",

package/src/core/config.ts

@@ -10,6 +10,7 @@ let config: Config = {
     unmask: [],
     regions: [],
     metrics: [],
+    dimensions: [],
     cookies: [],
     report: null,
     upload: null,

package/src/core/measure.ts

@@ -1,12 +1,13 @@
 import { Setting } from "@clarity-types/core";
 import { Metric } from "@clarity-types/data";
+import { report } from "@src/core/report";
 import * as metric from "@src/data/metric";
 
 // tslint:disable-next-line: ban-types
 export default function (method: Function): Function {
     return function (): void {
         let start = performance.now();
-        method.apply(this, arguments);
+        try { method.apply(this, arguments); } catch (ex) { throw report(ex); }
         let duration = performance.now() - start;
         metric.sum(Metric.TotalCost, duration);
         if (duration > Setting.LongTask) {

package/src/core/report.ts

@@ -1,7 +1,6 @@
 import { Report } from "@clarity-types/core";
-import { Check } from "@clarity-types/data";
 import config from "@src/core/config";
-import { data } from "@src/data/metadata";
+import { data } from "@src/data/envelope";
 
 let history: string[];
 
@@ -9,19 +8,21 @@ export function reset(): void {
     history = [];
 }
 
-export function report(check: Check, message: string = null): void {
+export function report(e: Error): Error {
     // Do not report the same message twice for the same page
-    if (history && history.indexOf(message) === -1) {
+    if (history && history.indexOf(e.message) === -1) {
         const url = config.report;
         if (url && url.length > 0) {
-            let payload: Report = {c: check, p: data.projectId, u: data.userId, s: data.sessionId, n: data.pageNum };
-            if (message) payload.m = message;
+            let payload: Report = {v: data.version, p: data.projectId, u: data.userId, s: data.sessionId, n: data.pageNum};
+            if (e.message) { payload.m = e.message; }
+            if (e.stack) { payload.e = e.stack; }
             // Using POST request instead of a GET request (img-src) to not violate existing CSP rules
             // Since, Clarity already uses XHR to upload data, we stick with similar POST mechanism for reporting too
             let xhr = new XMLHttpRequest();
             xhr.open("POST", url);
             xhr.send(JSON.stringify(payload));
-            history.push(message);
+            history.push(e.message);
         }
     }
+    return e;
 }

package/src/core/version.ts

@@ -1,2 +1,2 @@
-let version = "0.6.26";
+let version = "0.6.30";
 export default version;

package/src/data/limit.ts

@@ -1,6 +1,5 @@
 import { Check, Event, LimitData, Setting } from "@clarity-types/data";
 import * as clarity from "@src/clarity";
-import { report } from "@src/core/report";
 import { time } from "@src/core/time";
 import * as envelope from "@src/data/envelope";
 import * as metadata from "@src/data/metadata";
@@ -25,7 +24,6 @@ export function check(bytes: number): void {
 }
 
 export function trigger(reason: Check): void {
-    report(reason);
     data.check = reason;
     metadata.clear();
     clarity.stop();

package/src/data/metadata.ts

@@ -38,14 +38,16 @@ export function start(): void {
   dimension.log(Dimension.TabId, tab());
   dimension.log(Dimension.PageLanguage, document.documentElement.lang);
   dimension.log(Dimension.DocumentDirection, document.dir);
-
   if (navigator) {
     dimension.log(Dimension.Language, (<any>navigator).userLanguage || navigator.language);
+    metric.max(Metric.Automation, navigator.webdriver ? BooleanFlag.True : BooleanFlag.False);
+    userAgentData();
   }
 
   // Metrics
   metric.max(Metric.ClientTimestamp, s.ts);
   metric.max(Metric.Playback, BooleanFlag.False);
+
   if (screen) {
     metric.max(Metric.ScreenWidth, Math.round(screen.width));
     metric.max(Metric.ScreenHeight, Math.round(screen.height));
@@ -62,13 +64,39 @@ export function start(): void {
   track(u);
 }
 
+export function userAgentData(): void {
+  if (navigator["userAgentData"] && navigator["userAgentData"].getHighEntropyValues) {
+    navigator["userAgentData"].getHighEntropyValues(
+      ["model",
+      "platform",
+      "platformVersion",
+      "uaFullVersion"])
+      .then(ua => { 
+        dimension.log(Dimension.Platform, ua.platform); 
+        dimension.log(Dimension.PlatformVersion, ua.platformVersion); 
+        ua.brands?.forEach(brand => {
+          dimension.log(Dimension.Brand, brand.name + Constant.Tilde + brand.version); 
+        });
+        dimension.log(Dimension.Model, ua.model); 
+        metric.max(Metric.Mobile, ua.mobile ? BooleanFlag.True : BooleanFlag.False); 
+      });
+  }
+}
+
 export function stop(): void {
   callback = null;
   rootDomain = null;
+  data = null;
 }
 
-export function metadata(cb: MetadataCallback): void {
-  callback = cb;
+export function metadata(cb: MetadataCallback, wait: boolean = true): void {
+  if (data && wait === false) {
+    // Immediately invoke the callback if the caller explicitly doesn't want to wait for the upgrade confirmation
+    cb(data, !config.lean);
+  } else {
+    // Save the callback for future reference; so we can inform the caller when page gets upgraded and we have a valid playback flag
+    callback = cb;
+  }
 }
 
 export function id(): string {

package/src/data/upload.ts

@@ -56,6 +56,9 @@ export function queue(tokens: Token[], transmit: boolean = true): void {
                 break;
         }
 
+        // Increment event count metric
+        metric.count(Metric.EventCount);
+
         // Following two checks are precautionary and act as a fail safe mechanism to get out of unexpected situations.
         // Check 1: If for any reason the upload hasn't happened after waiting for 2x the config.delay time,
         // reset the timer. This allows Clarity to attempt an upload again.

package/src/diagnostic/encode.ts

@@ -1,10 +1,8 @@
 import { Event, Token } from "@clarity-types/data";
 import { time } from "@src/core/time";
 import { queue } from "@src/data/upload";
-import * as image from "@src/diagnostic/image";
 import * as internal from "@src/diagnostic/internal";
 import * as script from "@src/diagnostic/script";
-import { metadata } from "@src/layout/target";
 
 export default async function (type: Event): Promise<void> {
     let tokens: Token[] = [time(), type];
@@ -18,14 +16,6 @@ export default async function (type: Event): Promise<void> {
             tokens.push(script.data.source);
             queue(tokens);
             break;
-        case Event.ImageError:
-            if (image.data) {
-                let imageTarget = metadata(image.data.target as Node, type);
-                tokens.push(image.data.source);
-                tokens.push(imageTarget.id);
-                queue(tokens);
-            }
-            break;
         case Event.Log:
             if (internal.data) {
                 tokens.push(internal.data.code);

package/src/diagnostic/index.ts

@@ -1,14 +1,11 @@
-import * as image from "./image";
 import * as internal from "./internal";
 import * as script from "./script";
 
 export function start(): void {
     script.start();
-    image.start();
     internal.start();
 }
 
 export function stop(): void {
-    image.stop();
     internal.stop();
 }

package/src/interaction/clipboard.ts

@@ -0,0 +1,32 @@
+import { Event } from "@clarity-types/data";
+import { Clipboard, ClipboardState } from "@clarity-types/interaction";
+import { bind } from "@src/core/event";
+import { schedule } from "@src/core/task";
+import { time } from "@src/core/time";
+import encode from "./encode";
+import { target } from "@src/layout/target";
+
+export let state: ClipboardState[] = [];
+
+export function start(): void {
+    reset();
+}
+
+export function observe(root: Node): void {
+    bind(root, "cut", recompute.bind(this, Clipboard.Cut), true);
+    bind(root, "copy", recompute.bind(this, Clipboard.Copy), true);
+    bind(root, "paste", recompute.bind(this, Clipboard.Paste), true);
+}
+
+function recompute(action: Clipboard, evt: UIEvent): void {
+    state.push({ time: time(), event: Event.Clipboard, data: { target: target(evt), action } });
+    schedule(encode.bind(this, Event.Clipboard));
+}
+
+export function reset(): void {
+    state = [];
+}
+
+export function stop(): void {
+    reset();
+}

package/src/interaction/encode.ts

@@ -5,11 +5,13 @@ import * as baseline from "@src/data/baseline";
 import { queue } from "@src/data/upload";
 import { metadata } from "@src/layout/target";
 import * as click from "./click";
+import * as clipboard from "./clipboard";
 import * as input from "./input";
 import * as pointer from "./pointer";
 import * as resize from "./resize";
 import * as scroll from "./scroll";
 import * as selection from "./selection";
+import * as submit from "./submit";
 import * as timeline from "./timeline";
 import * as unload from "./unload";
 import * as visibility from "./visibility";
@@ -27,8 +29,7 @@ export default async function (type: Event): Promise<void> {
         case Event.TouchEnd:
         case Event.TouchMove:
         case Event.TouchCancel:
-            for (let i = 0; i < pointer.state.length; i++) {
-                let entry = pointer.state[i];
+            for (let entry of pointer.state) {
                 let pTarget = metadata(entry.data.target as Node, entry.event);
                 if (pTarget.id > 0) {
                     tokens = [entry.time, entry.event];
@@ -42,8 +43,7 @@ export default async function (type: Event): Promise<void> {
             pointer.reset();
             break;
         case Event.Click:
-            for (let i = 0; i < click.state.length; i++) {
-                let entry = click.state[i];
+            for (let entry of click.state) {
                 let cTarget = metadata(entry.data.target as Node, entry.event);
                 tokens = [entry.time, entry.event];
                 let cHash = cTarget.hash.join(Constant.Dot);
@@ -63,6 +63,18 @@ export default async function (type: Event): Promise<void> {
             }
             click.reset();
             break;
+        case Event.Clipboard:
+            for (let entry of clipboard.state) {
+                tokens = [entry.time, entry.event];
+                let target = metadata(entry.data.target as Node, entry.event);
+                if (target.id > 0) {
+                    tokens.push(target.id);
+                    tokens.push(entry.data.action);
+                    queue(tokens);
+                }
+            }
+            clipboard.reset();
+            break;
         case Event.Resize:
             let r = resize.data;
             tokens.push(r.width);
@@ -78,8 +90,7 @@ export default async function (type: Event): Promise<void> {
             queue(tokens);
             break;
         case Event.Input:
-            for (let i = 0; i < input.state.length; i++) {
-                let entry = input.state[i];
+            for (let entry of input.state) {
                 let iTarget = metadata(entry.data.target as Node, entry.event);
                 tokens = [entry.time, entry.event];
                 tokens.push(iTarget.id);
@@ -102,8 +113,7 @@ export default async function (type: Event): Promise<void> {
             }
             break;
         case Event.Scroll:
-            for (let i = 0; i < scroll.state.length; i++) {
-                let entry = scroll.state[i];
+            for (let entry of scroll.state) {
                 let sTarget = metadata(entry.data.target as Node, entry.event);
                 if (sTarget.id > 0) {
                     tokens = [entry.time, entry.event];
@@ -116,9 +126,19 @@ export default async function (type: Event): Promise<void> {
             }
             scroll.reset();
             break;
+        case Event.Submit:
+            for (let entry of submit.state) {
+                tokens = [entry.time, entry.event];
+                let target = metadata(entry.data.target as Node, entry.event);
+                if (target.id > 0) {
+                    tokens.push(target.id);
+                    queue(tokens);
+                }
+            }
+            submit.reset();
+            break;
         case Event.Timeline:
-            for (let i = 0; i < timeline.updates.length; i++) {
-                let entry = timeline.updates[i];
+            for (let entry of timeline.updates) {
                 tokens = [entry.time, entry.event];
                 tokens.push(entry.data.type);
                 tokens.push(entry.data.hash);

package/src/interaction/index.ts

@@ -1,9 +1,11 @@
 import * as click from "@src/interaction/click";
+import * as clipboard from "@src/interaction/clipboard";
 import * as input from "@src/interaction/input";
 import * as pointer from "@src/interaction/pointer";
 import * as resize from "@src/interaction/resize";
 import * as scroll from "@src/interaction/scroll";
 import * as selection from "@src/interaction/selection";
+import * as submit from "@src/interaction/submit";
 import * as timeline from "@src/interaction/timeline";
 import * as unload from "@src/interaction/unload";
 import * as visibility from "@src/interaction/visibility";
@@ -11,24 +13,28 @@ import * as visibility from "@src/interaction/visibility";
 export function start(): void {
     timeline.start();
     click.start();
+    clipboard.start();
     pointer.start();
     input.start();
     resize.start();
     visibility.start();
     scroll.start();
     selection.start();
+    submit.start();
     unload.start();
 }
 
 export function stop(): void {
     timeline.stop();
     click.stop();
+    clipboard.stop();
     pointer.stop();
     input.stop();
     resize.stop();
     visibility.stop();
     scroll.stop();
     selection.stop();
+    submit.stop();
     unload.stop()
 }
 
@@ -38,8 +44,10 @@ export function observe(root: Node): void {
     // In case of shadow DOM, following events automatically bubble up to the parent document.
     if (root.nodeType === Node.DOCUMENT_NODE) {
         click.observe(root);
+        clipboard.observe(root);
         pointer.observe(root);
         input.observe(root);
         selection.observe(root);
+        submit.observe(root);
     }
-}
+}

package/src/interaction/submit.ts

@@ -0,0 +1,30 @@
+import { Event } from "@clarity-types/data";
+import { SubmitState } from "@clarity-types/interaction";
+import { bind } from "@src/core/event";
+import { schedule } from "@src/core/task";
+import { time } from "@src/core/time";
+import encode from "./encode";
+import { target } from "@src/layout/target";
+
+export let state: SubmitState[] = [];
+
+export function start(): void {
+    reset();
+}
+
+export function observe(root: Node): void {
+    bind(root, "submit", recompute, true);
+}
+
+function recompute(evt: UIEvent): void {
+    state.push({ time: time(), event: Event.Submit, data: { target: target(evt) } });
+    schedule(encode.bind(this, Event.Submit));
+}
+
+export function reset(): void {
+    state = [];
+}
+
+export function stop(): void {
+    reset();
+}

package/src/layout/dom.ts

@@ -12,7 +12,7 @@ let index: number = 1;
 
 // Reference: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Input#%3Cinput%3E_types
 const DISALLOWED_TYPES = ["password", "hidden", "email", "tel"];
-const DISALLOWED_NAMES = ["addr", "cell", "code", "dob", "email", "mob", "name", "phone", "secret", "social", "ssn", "tel", "zip", "pass"];
+const DISALLOWED_NAMES = ["addr", "cell", "code", "dob", "email", "mob", "name", "phone", "secret", "social", "ssn", "tel", "zip", "pass", "card", "account", "cvv", "ccv"];
 const DISALLOWED_MATCH = ["address", "password", "contact"];
 
 let nodes: Node[] = [];
@@ -56,6 +56,7 @@ export function parse(root: ParentNode): void {
         if ("querySelectorAll" in root) {
             extract.regions(root, config.regions);
             extract.metrics(root, config.metrics);
+            extract.dimensions(root, config.dimensions);
             config.mask.forEach(x => root.querySelectorAll(x).forEach(e => privacyMap.set(e, Privacy.TextImage))); // Masked Elements
             config.unmask.forEach(x => root.querySelectorAll(x).forEach(e => privacyMap.set(e, Privacy.None))); // Unmasked Elements
         }

package/src/layout/extract.ts

@@ -1,5 +1,6 @@
-import { Extract, Metric, Region, RegionFilter } from "@clarity-types/core";
-import { Constant } from "@clarity-types/data";
+import { Dimension, Extract, Metric, Region, RegionFilter } from "@clarity-types/core";
+import { Constant, Setting } from "@clarity-types/data";
+import * as dimension from "@src/data/dimension";
 import * as metric from "@src/data/metric";
 import * as region from "@src/layout/region";
 
@@ -33,6 +34,19 @@ export function metrics(root: ParentNode, value: Metric[]): void {
     }
 }
 
+export function dimensions(root: ParentNode, value: Dimension[]): void {
+    for (let v of value) {
+        const [dimensionId, source, match] = v;
+        if (match) {
+            switch (source) {
+                case Extract.Text:  root.querySelectorAll(match).forEach(e => { dimension.log(dimensionId, str((e as HTMLElement).innerText)); }); break;
+                case Extract.Attribute: root.querySelectorAll(`[${match}]`).forEach(e => { dimension.log(dimensionId, str(e.getAttribute(match))); }); break;
+                case Extract.Javascript: dimension.log(dimensionId, str(evaluate(match, Constant.String))); break;
+            }
+        }
+    }
+}
+
 function regex(match: string): RegExp {
     regexCache[match] = match in regexCache ? regexCache[match] : new RegExp(match);
     return regexCache[match];
@@ -52,6 +66,11 @@ function evaluate(variable: string, type: string = null, base: Object = window):
     return null;
 }
 
+function str(input: string): string {
+    // Automatically trim string to max of Setting.DimensionLimit to avoid fetching long strings
+    return input ? input.substr(0, Setting.DimensionLimit) : input;
+}
+
 function num(text: string, scale: number, localize: boolean = true): number {
     try {
         scale = scale || 1; 

package/src/layout/mutation.ts

@@ -36,7 +36,7 @@ export function start(): void {
 
     if (insertRule === null) { insertRule = CSSStyleSheet.prototype.insertRule; }
     if (deleteRule === null) { deleteRule = CSSStyleSheet.prototype.deleteRule; }
-    if (attachShadow === null) { attachShadow = HTMLElement.prototype.attachShadow; }
+    if (attachShadow === null) { attachShadow = Element.prototype.attachShadow; }
 
     // Some popular open source libraries, like styled-components, optimize performance
     // by injecting CSS using insertRule API vs. appending text node. A side effect of
@@ -52,10 +52,14 @@ export function start(): void {
       return deleteRule.apply(this, arguments);
     };
 
-    // Listening to attachShadow API
-    HTMLElement.prototype.attachShadow = function (): ShadowRoot {
-      return schedule(attachShadow.apply(this, arguments)) as ShadowRoot;
-    }
+    // Add a hook to attachShadow API calls
+    // In case we are unable to add a hook and browser throws an exception,
+    // reset attachShadow variable and resume processing like before
+    try {
+      Element.prototype.attachShadow = function (): ShadowRoot {
+        return schedule(attachShadow.apply(this, arguments)) as ShadowRoot;
+      }
+    } catch { attachShadow = null; }
 }
 
 export function observe(node: Node): void {
@@ -103,7 +107,7 @@ export function stop(): void {
 
   // Restoring original attachShadow
   if (attachShadow != null) {
-    HTMLElement.prototype.attachShadow = attachShadow;
+    Element.prototype.attachShadow = attachShadow;
     attachShadow = null;
   }
 

package/src/layout/selector.ts

@@ -24,12 +24,13 @@ export default function(input: SelectorInput, beta: boolean = false): string {
             let selector = `${prefix}${input.tag}${suffix}`;
             let classes = Constant.Class in a && a[Constant.Class].length > 0 ? a[Constant.Class].trim().split(/\s+/) : null;
             if (beta) {
-                // In beta mode, update selector to use "id" field when available
-                // The only exception is if "id" appears to be an auto generated string token, e.g. guid or a random id
+                // In beta mode, update selector to use "id" field when available. There are two exceptions:
+                // (1) if "id" appears to be an auto generated string token, e.g. guid or a random id containing digits
+                // (2) if "id" appears inside a shadow DOM, in which case we continue to prefix up to shadow DOM to prevent conflicts
                 let id = Constant.Id in a && a[Constant.Id].length > 0 ? a[Constant.Id] : null;
                 classes = input.tag !== Constant.BodyTag && classes ? classes.filter(c => !hasDigits(c)) : [];
                 selector = classes.length > 0 ? `${prefix}${input.tag}.${classes.join(".")}${suffix}` : selector;
-                selector = id && hasDigits(id) === false ? `#${id}` : selector;
+                selector = id && hasDigits(id) === false ? `${getDomPrefix(prefix)}#${id}` : selector;
             } else {
                 // Otherwise, fallback to stable mode, where we include class names as part of the selector
                 selector = classes ? `${prefix}${input.tag}.${classes.join(".")}${suffix}` : selector;
@@ -38,11 +39,24 @@ export default function(input: SelectorInput, beta: boolean = false): string {
     }
 }
 
+function getDomPrefix(prefix: string): string {
+  const shadowDomStart = prefix.lastIndexOf(Constant.ShadowDomTag);
+  const iframeDomStart = prefix.lastIndexOf(`${Constant.IFramePrefix}${Constant.HTML}`);
+  const domStart = Math.max(shadowDomStart, iframeDomStart);
+  
+  if (domStart < 0) {
+    return "";
+  }
+
+  const domEnd = prefix.indexOf(">", domStart) + 1;
+  return prefix.substr(0, domEnd);
+}
+
 // Check if the given input string has digits or not
 function hasDigits(value: string): boolean {
     for (let i = 0; i < value.length; i++) {
         let c = value.charCodeAt(i);
-        return c >= Character.Zero && c <= Character.Nine;
+        if (c >= Character.Zero && c <= Character.Nine) { return true };
     }
     return false;
 }

package/src/performance/encode.ts

@@ -1,21 +1,12 @@
 import {Event, Token} from "@clarity-types/data";
 import { time } from "@src/core/time";
 import { queue } from "@src/data/upload";
-import * as connection from "@src/performance/connection";
 import * as navigation from "@src/performance/navigation";
 
 export default async function(type: Event): Promise<void> {
     let t = time();
     let tokens: Token[] = [t, type];
     switch (type) {
-        case Event.Connection:
-            tokens.push(connection.data.downlink);
-            tokens.push(connection.data.rtt);
-            tokens.push(connection.data.saveData);
-            tokens.push(connection.data.type);
-            connection.reset();
-            queue(tokens, false);
-            break;
         case Event.Navigation:
             tokens.push(navigation.data.fetchStart);
             tokens.push(navigation.data.connectStart);

package/src/performance/index.ts

@@ -1,15 +1,12 @@
-import * as connection from "@src/performance/connection";
 import * as navigation from "@src/performance/navigation";
 import * as observer from "@src/performance/observer";
 
 export function start(): void {
     navigation.reset();
-    connection.start();
     observer.start();
 }
 
 export function stop(): void {
     observer.stop();
-    connection.stop();
     navigation.reset();
 }

package/test/helper.ts

@@ -1,5 +1,6 @@
 import { Core, Data, Layout } from "clarity-decode";
 import * as fs from 'fs';
+import * as url from 'url';
 import * as path from 'path';
 import { Browser, Page, chromium } from 'playwright';
 
@@ -8,7 +9,13 @@ export async function launch(): Promise<Browser> {
 }
 
 export async function markup(page: Page, file: string, override: Core.Config = null): Promise<string[]> {
-    const html = fs.readFileSync(path.resolve(__dirname, `./html/${file}`), 'utf8');
+    const htmlPath = path.resolve(__dirname, `./html/${file}`);
+    const htmlFileUrl = url.pathToFileURL(htmlPath).toString();
+    const html = fs.readFileSync(htmlPath, 'utf8');
+    await Promise.all([
+        page.goto(htmlFileUrl),
+        page.waitForNavigation()
+    ]);
     await page.setContent(html.replace("</body>", `
         <script>
           window.payloads = [];
@@ -17,6 +24,7 @@ export async function markup(page: Page, file: string, override: Core.Config = n
         </script>
         </body>
     `));
+    await page.hover("#two");
     await page.waitForFunction("payloads && payloads.length > 1");
     return await page.evaluate('payloads');
 }
@@ -34,7 +42,7 @@ export function node(decoded: Data.DecodedPayload[], key: string, value: string
     }
 
     // Walking over the decoded payload to find the right match
-    for (let i = decoded.length - 1; i > 0; i--) {
+    for (let i = decoded.length - 1; i >= 0; i--) {
         if (decoded[i].dom) {
             for (let j = 0; j < decoded[i].dom.length; j++) {
                 if (decoded[i].dom[j].data) {

package/types/core.d.ts

@@ -5,6 +5,7 @@ type TaskResolve = () => void;
 type UploadCallback = (data: string) => void;
 type Region = [number /* RegionId */, string /* Query Selector */, RegionFilter? /* Region Filter */, string? /* Filter Text */];
 type Metric = [Data.Metric /* MetricId */, Extract /* Extract Filter */, string /* Match Value */, number? /* Scale Factor */];
+type Dimension = [Data.Dimension /* DimensionId */, Extract /* Extract Filter */, string /* Match Value */];
 
 /* Enum */
 
@@ -100,12 +101,13 @@ export interface BrowserEvent {
 }
 
 export interface Report {
-    c: Data.Check; // Reporting code
+    v: string; // Version
     p: string; // Project Id
     u: string; // User Id
     s: string; // Session Id
     n: number; // Page Number
     m?: string; // Message, optional
+    e?: string; // Error Stack, optional
 }
 
 export interface Config {
@@ -118,6 +120,7 @@ export interface Config {
     unmask?: string[];
     regions?: Region[];
     metrics?: Metric[];
+    dimensions?: Dimension[];
     cookies?: string[];
     report?: string;
     upload?: string | UploadCallback;