@lwrjs/o11y 0.6.0-alpha.8 → 0.6.1

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

@@ -1 +1 @@
-import{getInstrumentation as t}from"o11y/client";import{registerDecorators as r}from"lwc";class e{constructor(t){this.marks={},this.instrumentation=t}track(){this.trackExistingMarks(),this.setupObserver()}trackExistingMarks(){const t=performance.getEntriesByType("mark").filter((t=>t.name.startsWith("lwr.bootstrap.")));for(const r of t){const{name:t}=r;this.marks[t]=r,performance.clearMarks(t)}}setupObserver(){let t=0;new PerformanceObserver((r=>{const e=[];r.getEntries().forEach((r=>{const{name:s,entryType:a}=r;"mark"===a&&s.startsWith("lwr.")&&e.push(r),"lwr.bootstrap.end"===s&&(this.marks[s]=r),"lwr.bootstrap.error"===s&&(t+=1)})),void 0!==this.marks["lwr.bootstrap.end"]&&(this.instrumentation.trackValue("lwr.bootstrap.duration",this.marks["lwr.bootstrap.end"].startTime),this.instrumentation.trackValue("lwr.bootstrap.availability",1/(1+t)*100),delete this.marks["lwr.bootstrap.end"]);const s=e.reduce(((t,r)=>r.name.startsWith("lwr.loader.module.fetch")?t+1:t),0);s>0&&this.instrumentation.incrementCounter("lwr.loader.module.fetch.count",s);const a=e.reduce(((t,r)=>r.name.startsWith("lwr.loader.mappings.fetch")?t+1:t),0);a>0&&this.instrumentation.incrementCounter("lwr.loader.mappings.fetch.count",a),e.forEach((t=>performance.clearMarks(t.name)))})).observe({entryTypes:["mark"]})}}r(e,{fields:["marks"]});const s=void 0!==globalThis.performance&&"function"==typeof globalThis.performance.mark,a={track:()=>{}};function o(r){const o=t("lwrjs.instrumentation");(s?new e(o):a).track()}export default o;
+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;

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

@@ -10,12 +10,13 @@ const noop = () => {// noop
 const noopSink = {
   track: noop
 };
+const NAMESPACE = 'lwrjs';
 /**
  * Sets up o11y instrumentation instance.
  */
 
-export default function hookO11yClient(loaderServices) {
-  const instrumentation = getInstrumentation('lwrjs.instrumentation');
+export default function hookO11yClient(serviceApi) {
+  const instrumentation = getInstrumentation(NAMESPACE);
   const sink = isPerfSupported ? new PerformanceApiSink(instrumentation) : noopSink;
   sink.track();
 }

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

@@ -1,13 +1,4 @@
-// TODO: import constants from shared util module
-const BOOTSTRAP_MARK = 'lwr.bootstrap.';
-const BOOTSTRAP_END_MARK = 'lwr.bootstrap.end';
-const BOOTSTRAP_ERROR_MARK = 'lwr.bootstrap.error';
-const BOOTSTRAP_DURATION_OP = 'lwr.bootstrap.duration';
-const BOOTSTRAP_AVAILABILITY_OP = 'lwr.bootstrap.availability';
-const LOADER_MODULE_FETCH = 'lwr.loader.module.fetch';
-const LOADER_MODULE_FETCH_COUNT = 'lwr.loader.module.fetch.count';
-const LOADER_MAPPING_FETCH = 'lwr.loader.mappings.fetch';
-const LOADER_MAPPING_FETCH_COUNT = 'lwr.loader.mappings.fetch.count';
+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';
 export class PerformanceApiSink {
   marks = {};
 
@@ -18,23 +9,29 @@ export class PerformanceApiSink {
   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
 
 
   trackExistingMarks() {
     /**
-     * Bootstrap marks prior to service bootstrap:
-     * - lwr.bootstrap.init
-     * - lwr.bootstrap.application
+     * Loader define marks prior to service bootstrap
      */
-    const marks = performance.getEntriesByType('mark').filter(e => e.name.startsWith(BOOTSTRAP_MARK)); // TODO: saved these marks for now, but do we have real usages for them?
-
-    for (const mark of marks) {
-      const {
-        name
-      } = mark;
-      this.marks[name] = mark;
-      performance.clearMarks(name);
+    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:
+    //      - required modules
+    //      - preload modules
+    //      - the application bootstrap module
+    //      - the loader module itself
+
+    if (marks.length > 0) {
+      this.instrumentation.incrementCounter(MODULE_DEFINE_COUNT, marks.length);
     }
   } // Add observer to log future metrics
   // observe lwr client runtime performance metrics
@@ -42,65 +39,88 @@ export class PerformanceApiSink {
 
   setupObserver() {
     let bootstrapErrorCount = 0;
+    let loaderModuleErrorCount = 0;
+    let loaderMappingsErrorcount = 0;
     const observer = new PerformanceObserver(list => {
       // grab the lwr performance marks
       const marks = [];
       /**
-       * Bootstrap marks after to service bootstrap:
-       * - lwr.bootstrap.end
-       * - lwr.bootstrap.error
-       * Loader marks
-       * - lwr.loader.*
+       * Bootstrap and Loader marks
        */
 
       list.getEntries().forEach(entry => {
         const {
           name,
-          entryType
+          entryType,
+          duration
         } = entry;
 
         if (entryType === 'mark' && name.startsWith('lwr.')) {
           marks.push(entry);
         }
 
-        if (name === BOOTSTRAP_END_MARK) {
+        if (name === BOOTSTRAP_END) {
           this.marks[name] = entry;
         }
 
-        if (name === BOOTSTRAP_ERROR_MARK) {
+        if (name === BOOTSTRAP_ERROR) {
           bootstrapErrorCount += 1;
         }
+
+        if (name === MODULE_ERROR) {
+          loaderModuleErrorCount += 1;
+        }
+
+        if (name === MAPPINGS_ERROR) {
+          loaderMappingsErrorcount += 1;
+        }
+
+        if (name.startsWith(MODULE_FETCH_DURATION) || name.startsWith(MAPPINGS_FETCH_DURATION)) {
+          this.instrumentation.trackValue(name, duration);
+        }
       });
 
-      if (this.marks[BOOTSTRAP_END_MARK] !== undefined) {
-        this.instrumentation.trackValue(BOOTSTRAP_DURATION_OP, this.marks[BOOTSTRAP_END_MARK].startTime);
-        this.instrumentation.trackValue(BOOTSTRAP_AVAILABILITY_OP, 1 / (1 + bootstrapErrorCount) * 100); // reset to prevent multiple reports
+      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
+
 
-        delete this.marks[BOOTSTRAP_END_MARK];
+      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(LOADER_MODULE_FETCH) ? count + 1 : count;
+        return mark.name.startsWith(MODULE_FETCH) ? count + 1 : count;
       }, 0);
 
       if (moduleLoadCount > 0) {
-        this.instrumentation.incrementCounter(LOADER_MODULE_FETCH_COUNT, moduleLoadCount);
+        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(LOADER_MAPPING_FETCH) ? count + 1 : count;
+        return mark.name.startsWith(MAPPINGS_FETCH) ? count + 1 : count;
       }, 0);
 
       if (mappingLoadCount > 0) {
-        this.instrumentation.incrementCounter(LOADER_MAPPING_FETCH_COUNT, mappingLoadCount);
-      }
+        this.instrumentation.incrementCounter(MAPPINGS_FETCH_COUNT, mappingLoadCount);
+        this.instrumentation.trackValue(MAPPINGS_AVAILABILITY, mappingLoadCount / (mappingLoadCount + loaderMappingsErrorcount) * 100);
+      } // remove clearable marks
+
 
-      marks.forEach(mark => performance.clearMarks(mark.name));
+      marks.forEach(mark => this.isClearable(mark.name) && performance.clearMarks(mark.name));
     });
     observer.observe({
-      entryTypes: ['mark']
+      entryTypes: ['mark', 'measure']
     });
   }
 

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.6.0-alpha.8",
+    "version": "0.6.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.0-alpha.8",
-        "o11y": "238.1.2"
+        "@lwrjs/shared-utils": "0.6.1",
+        "o11y": "238.1.4"
     },
     "devDependencies": {
         "rollup-plugin-terser": "^7.0.2"
@@ -46,5 +46,5 @@
     "engines": {
         "node": ">=14.15.4 <17"
     },
-    "gitHead": "f57b843b079ef42fdd1e727521e5a88e70bf850a"
+    "gitHead": "4d7c44dfae958fe24ef1c94b0f60aa2b15e12f24"
 }