@lwrjs/o11y 0.6.2 → 0.7.0-alpha.1

package/build/bundle/prod/lwr/o11yService/o11yService.js

@@ -1 +1 @@
-import{getInstrumentation as t}from"o11y/client";import{registerDecorators as r}from"lwc";import{MODULE_FETCH as e,MAPPINGS_FETCH as s,MODULE_DEFINE as n,MODULE_DEFINE_COUNT as i,BOOTSTRAP_END as a,MODULE_FETCH_DURATION as o,MAPPINGS_FETCH_DURATION as m,BOOTSTRAP_DURATION as c,BOOTSTRAP_AVAILABILITY as h,MODULE_FETCH_COUNT as u,MODULE_AVAILABILITY as l,MAPPINGS_FETCH_COUNT as k,MAPPINGS_AVAILABILITY as f,BOOTSTRAP_ERROR as p,MODULE_ERROR as d,MAPPINGS_ERROR as W}from"lwr/metrics";class b{constructor(t){this.marks={},this.instrumentation=t}track(){this.trackExistingMarks(),this.setupObserver()}isClearable(t){return!t.startsWith(e)&&!t.startsWith(s)}trackExistingMarks(){const t=performance.getEntriesByType("mark").filter((t=>t.name.startsWith(n)));t.length>0&&this.instrumentation.incrementCounter(i,t.length)}setupObserver(){let t=0,r=0,b=0;new PerformanceObserver((g=>{const y=[];g.getEntries().forEach((e=>{const{name:s,entryType:n,duration:i}=e;"mark"===n&&s.startsWith("lwr.")&&y.push(e),s===a&&(this.marks[s]=e),s===p&&(t+=1),s===d&&(r+=1),s===W&&(b+=1),(s.startsWith(o)||s.startsWith(m))&&this.instrumentation.trackValue(s,i)})),void 0!==this.marks[a]&&(this.instrumentation.trackValue(c,this.marks[a].startTime),this.instrumentation.trackValue(h,1/(1+t)*100),delete this.marks[a]);const v=y.reduce(((t,r)=>r.name.startsWith(n)?t+1:t),0);v>0&&this.instrumentation.incrementCounter(i,v);const w=y.reduce(((t,r)=>r.name.startsWith(e)?t+1:t),0);w>0&&(this.instrumentation.incrementCounter(u,w),this.instrumentation.trackValue(l,w/(w+r)*100));const C=y.reduce(((t,r)=>r.name.startsWith(s)?t+1:t),0);C>0&&(this.instrumentation.incrementCounter(k,C),this.instrumentation.trackValue(f,C/(C+b)*100)),y.forEach((t=>this.isClearable(t.name)&&performance.clearMarks(t.name)))})).observe({entryTypes:["mark","measure"]})}}r(b,{fields:["marks"]});const g=void 0!==globalThis.performance&&"function"==typeof globalThis.performance.mark,y={track:()=>{}};function v(r){const e=t("lwrjs");(g?new b(e):y).track()}export default v;
+import{getInstrumentation as t}from"o11y/client";import{MODULE_DEFINE as e,MODULE_DEFINE_COUNT as r,BOOTSTRAP_END as n,BOOTSTRAP_DURATION as s,MODULE_FETCH_DURATION as i,MAPPINGS_FETCH_DURATION as a,MODULE_FETCH as o,MAPPINGS_FETCH as c,ROUTER_NAV as m,ROUTER_VIEW as h,ROUTER_NAV_DURATION as l,ROUTER_VIEW_DURATION as u,BOOTSTRAP_ERROR as f,BOOTSTRAP_ERROR_COUNT as k,MODULE_FETCH_COUNT as g,MODULE_ERROR as p,MODULE_ERROR_COUNT as b,MAPPINGS_FETCH_COUNT as T,MAPPINGS_ERROR as y,MAPPINGS_ERROR_COUNT as W,ROUTER_NAV_COUNT as d,ROUTER_ERROR as v,ROUTER_ERROR_COUNT as E}from"lwr/metrics";const M=[o,c,m,h],w=[l,u],O={[f]:k,[e]:r,[o]:g,[p]:b,[c]:T,[y]:W,[m]:d,[v]:E},V=Object.keys(O);class x{constructor(t,e){this.config=e||{},this.instrumentation=t}track(){this.trackExistingMarks(),this.setupObserver()}trackExistingMarks(){const t=performance.getEntriesByType("mark").filter((t=>t.name.startsWith(e)));t.length>0&&this.instrumentation.incrementCounter(r,t.length)}setupObserver(){new PerformanceObserver((t=>{t.getEntries().forEach((t=>{const{name:e,duration:r,startTime:o}=t;e===n&&this.instrumentation.trackValue(s,o);const c=V.find((t=>e.startsWith(t)));c&&this.instrumentation.incrementCounter(O[c],1),this.config.enableModuleFetchTracking&&e.startsWith(i)&&this.instrumentation.trackValue(e,r),this.config.enableMappingFetchTracking&&e.startsWith(a)&&this.instrumentation.trackValue(e,r),w.some((t=>e.startsWith(t)))&&this.instrumentation.trackValue(e,r),M.some((t=>e.startsWith(t)))||performance.clearMarks(e)}))})).observe({entryTypes:["mark","measure"]})}}const C=void 0!==globalThis.performance&&"function"==typeof globalThis.performance.mark,j=globalThis.LWR,F={track:()=>{}};function B(e){const r=t("lwrjs"),n=j.metricsConfig||{};(C?new x(r,n):F).track()}export default B;

package/build/modules/lwr/o11yService/o11yService.js

@@ -3,6 +3,7 @@ import { PerformanceApiSink } from './performanceApiSink'; // Check if the Perfo
 // e.g. JSDom (used in Jest) doesn't implement these
 
 const isPerfSupported = typeof globalThis.performance !== 'undefined' && typeof globalThis.performance.mark === 'function';
+const clientBootstrapConfig = globalThis.LWR;
 
 const noop = () => {// noop
 };
@@ -17,6 +18,7 @@ const NAMESPACE = 'lwrjs';
 
 export default function hookO11yClient(serviceApi) {
   const instrumentation = getInstrumentation(NAMESPACE);
-  const sink = isPerfSupported ? new PerformanceApiSink(instrumentation) : noopSink;
+  const metricsConfig = clientBootstrapConfig.metricsConfig || {};
+  const sink = isPerfSupported ? new PerformanceApiSink(instrumentation, metricsConfig) : noopSink;
   sink.track();
 }

package/build/modules/lwr/o11yService/performanceApiSink.js

@@ -1,123 +1,82 @@
-import { BOOTSTRAP_AVAILABILITY, BOOTSTRAP_DURATION, BOOTSTRAP_END, BOOTSTRAP_ERROR, MAPPINGS_AVAILABILITY, MAPPINGS_ERROR, MAPPINGS_FETCH, MAPPINGS_FETCH_COUNT, MAPPINGS_FETCH_DURATION, MODULE_AVAILABILITY, MODULE_DEFINE, MODULE_DEFINE_COUNT, MODULE_ERROR, MODULE_FETCH, MODULE_FETCH_COUNT, MODULE_FETCH_DURATION } from 'lwr/metrics';
+import { BOOTSTRAP_DURATION, BOOTSTRAP_END, BOOTSTRAP_ERROR, BOOTSTRAP_ERROR_COUNT, MAPPINGS_ERROR, MAPPINGS_ERROR_COUNT, MAPPINGS_FETCH, MAPPINGS_FETCH_COUNT, MAPPINGS_FETCH_DURATION, MODULE_DEFINE, MODULE_DEFINE_COUNT, MODULE_ERROR, MODULE_ERROR_COUNT, MODULE_FETCH, MODULE_FETCH_COUNT, MODULE_FETCH_DURATION, ROUTER_ERROR, ROUTER_ERROR_COUNT, ROUTER_NAV, ROUTER_NAV_COUNT, ROUTER_NAV_DURATION, ROUTER_VIEW, ROUTER_VIEW_DURATION } from 'lwr/metrics';
+const doNotClear = [MODULE_FETCH, MAPPINGS_FETCH, ROUTER_NAV, ROUTER_VIEW];
+const durationMetrics = [ROUTER_NAV_DURATION, ROUTER_VIEW_DURATION];
+const countMap = {
+  [BOOTSTRAP_ERROR]: BOOTSTRAP_ERROR_COUNT,
+  [MODULE_DEFINE]: MODULE_DEFINE_COUNT,
+  [MODULE_FETCH]: MODULE_FETCH_COUNT,
+  [MODULE_ERROR]: MODULE_ERROR_COUNT,
+  [MAPPINGS_FETCH]: MAPPINGS_FETCH_COUNT,
+  [MAPPINGS_ERROR]: MAPPINGS_ERROR_COUNT,
+  [ROUTER_NAV]: ROUTER_NAV_COUNT,
+  [ROUTER_ERROR]: ROUTER_ERROR_COUNT
+};
+const metricsToCount = Object.keys(countMap);
 export class PerformanceApiSink {
-  marks = {};
-
-  constructor(instrumentation) {
+  constructor(instrumentation, config) {
+    this.config = config || {};
     this.instrumentation = instrumentation;
   }
 
   track() {
     this.trackExistingMarks();
     this.setupObserver();
-  } // Return true if the mark is clearable
-  // logOperationEnd clears the marks and measures passed to it, so these are NOT clearable
-  // As of now, only "lwr.loader.*.fetch" metrics have durations (i.e. are not clearable)
-
-
-  isClearable(name) {
-    return !name.startsWith(MODULE_FETCH) && !name.startsWith(MAPPINGS_FETCH);
-  } // Retrieve existing metrics to this point
+  } // Retrieve existing loader define metrics to this point
 
 
   trackExistingMarks() {
-    /**
-     * Loader define marks prior to service bootstrap
-     */
-    const marks = performance.getEntriesByType('mark').filter(e => e.name.startsWith(MODULE_DEFINE)); // initialize the module define count
-    // at this point in time, the count will include modules NOT fetched by the loader:
+    const defineMarks = performance.getEntriesByType('mark').filter(e => e.name.startsWith(MODULE_DEFINE)); // Initialize the module define count
+    // At this point in time, the count will include modules NOT fetched by the loader:
     //      - required modules
     //      - preload modules
     //      - the application bootstrap module
     //      - the loader module itself
 
-    if (marks.length > 0) {
-      this.instrumentation.incrementCounter(MODULE_DEFINE_COUNT, marks.length);
+    if (defineMarks.length > 0) {
+      this.instrumentation.incrementCounter(MODULE_DEFINE_COUNT, defineMarks.length);
     }
   } // Add observer to log future metrics
-  // observe lwr client runtime performance metrics
 
 
   setupObserver() {
-    let bootstrapErrorCount = 0;
-    let loaderModuleErrorCount = 0;
-    let loaderMappingsErrorcount = 0;
     const observer = new PerformanceObserver(list => {
-      // grab the lwr performance marks
-      const marks = [];
-      /**
-       * Bootstrap and Loader marks
-       */
-
       list.getEntries().forEach(entry => {
         const {
           name,
-          entryType,
-          duration
-        } = entry;
-
-        if (entryType === 'mark' && name.startsWith('lwr.')) {
-          marks.push(entry);
-        }
+          duration,
+          startTime
+        } = entry; // Track the bootstrap duration from navigation.start to lwr.bootstrap.end
 
         if (name === BOOTSTRAP_END) {
-          this.marks[name] = entry;
-        }
+          this.instrumentation.trackValue(BOOTSTRAP_DURATION, startTime);
+        } // Increment count metrics
 
-        if (name === BOOTSTRAP_ERROR) {
-          bootstrapErrorCount += 1;
-        }
 
-        if (name === MODULE_ERROR) {
-          loaderModuleErrorCount += 1;
-        }
+        const metricToCount = metricsToCount.find(c => name.startsWith(c));
 
-        if (name === MAPPINGS_ERROR) {
-          loaderMappingsErrorcount += 1;
-        }
+        if (metricToCount) {
+          this.instrumentation.incrementCounter(countMap[metricToCount], 1);
+        } // Record duration metrics
 
-        if (name.startsWith(MODULE_FETCH_DURATION) || name.startsWith(MAPPINGS_FETCH_DURATION)) {
+
+        if (this.config.enableModuleFetchTracking && name.startsWith(MODULE_FETCH_DURATION)) {
           this.instrumentation.trackValue(name, duration);
         }
-      });
-
-      if (this.marks[BOOTSTRAP_END] !== undefined) {
-        this.instrumentation.trackValue(BOOTSTRAP_DURATION, this.marks[BOOTSTRAP_END].startTime);
-        this.instrumentation.trackValue(BOOTSTRAP_AVAILABILITY, 1 / (1 + bootstrapErrorCount) * 100); // reset to prevent multiple reports
 
-        delete this.marks[BOOTSTRAP_END];
-      } // count how many modules were defined and report the count
-
-
-      const moduleDefineCount = marks.reduce((count, mark) => {
-        return mark.name.startsWith(MODULE_DEFINE) ? count + 1 : count;
-      }, 0);
-
-      if (moduleDefineCount > 0) {
-        this.instrumentation.incrementCounter(MODULE_DEFINE_COUNT, moduleDefineCount);
-      } // count how many modules were loaded and report the count
-
-
-      const moduleLoadCount = marks.reduce((count, mark) => {
-        return mark.name.startsWith(MODULE_FETCH) ? count + 1 : count;
-      }, 0);
-
-      if (moduleLoadCount > 0) {
-        this.instrumentation.incrementCounter(MODULE_FETCH_COUNT, moduleLoadCount);
-        this.instrumentation.trackValue(MODULE_AVAILABILITY, moduleLoadCount / (moduleLoadCount + loaderModuleErrorCount) * 100);
-      } // count how many mapping resources were loaded and report the count
-
-
-      const mappingLoadCount = marks.reduce((count, mark) => {
-        return mark.name.startsWith(MAPPINGS_FETCH) ? count + 1 : count;
-      }, 0);
+        if (this.config.enableMappingFetchTracking && name.startsWith(MAPPINGS_FETCH_DURATION)) {
+          this.instrumentation.trackValue(name, duration);
+        }
 
-      if (mappingLoadCount > 0) {
-        this.instrumentation.incrementCounter(MAPPINGS_FETCH_COUNT, mappingLoadCount);
-        this.instrumentation.trackValue(MAPPINGS_AVAILABILITY, mappingLoadCount / (mappingLoadCount + loaderMappingsErrorcount) * 100);
-      } // remove clearable marks
+        if (durationMetrics.some(d => name.startsWith(d))) {
+          this.instrumentation.trackValue(name, duration);
+        } // Remove clearable marks
+        // A mark is clearable if it does not have a corresponding logOperationEnd / measure
 
 
-      marks.forEach(mark => this.isClearable(mark.name) && performance.clearMarks(mark.name));
+        if (!doNotClear.some(m => name.startsWith(m))) {
+          performance.clearMarks(name);
+        }
+      });
     });
     observer.observe({
       entryTypes: ['mark', 'measure']

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.6.2",
+    "version": "0.7.0-alpha.1",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -24,8 +24,8 @@
         "build:bundle": "rollup --config scripts/rollup.moduleBundle.config.cjs"
     },
     "dependencies": {
-        "@lwrjs/shared-utils": "0.6.2",
-        "o11y": "238.1.4"
+        "@lwrjs/shared-utils": "0.7.0-alpha.1",
+        "o11y": "238.9.0"
     },
     "devDependencies": {
         "rollup-plugin-terser": "^7.0.2"
@@ -46,5 +46,5 @@
     "engines": {
         "node": ">=14.15.4 <17"
     },
-    "gitHead": "ef85bdc48adde58b7c648561d67acbb408bbe189"
+    "gitHead": "24245670d6908d37e465f2316f92385df63d22aa"
 }