@lwrjs/o11y 0.6.0-alpha.9 → 0.6.2

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.loader.module.define")));t.length>0&&this.instrumentation.incrementCounter("lwr.loader.module.define.count",t.length)}setupObserver(){let t=0;new PerformanceObserver((r=>{const e=[];r.getEntries().forEach((r=>{const{name:n,entryType:s}=r;"mark"===s&&n.startsWith("lwr.")&&e.push(r),"lwr.bootstrap.end"===n&&(this.marks[n]=r),"lwr.bootstrap.error"===n&&(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 n=e.reduce(((t,r)=>r.name.startsWith("lwr.loader.module.define")?t+1:t),0);n>0&&this.instrumentation.incrementCounter("lwr.loader.module.define.count",n);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 o=e.reduce(((t,r)=>r.name.startsWith("lwr.loader.mappings.fetch")?t+1:t),0);o>0&&this.instrumentation.incrementCounter("lwr.loader.mappings.fetch.count",o),e.forEach((t=>performance.clearMarks(t.name)))})).observe({entryTypes:["mark"]})}}r(e,{fields:["marks"]});const n=void 0!==globalThis.performance&&"function"==typeof globalThis.performance.mark,s={track:()=>{}};function o(r){const o=t("lwrjs.instrumentation");(n?new e(o):s).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,14 +1,4 @@
-// TODO: import constants from shared util module
-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_DEFINE = 'lwr.loader.module.define';
-const LOADER_MODULE_DEFINE_COUNT = 'lwr.loader.module.define.count';
-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 = {};
 
@@ -19,15 +9,21 @@ 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() {
     /**
-     * Loader marks prior to service bootstrap:
-     * - lwr.loader.module.define
+     * Loader define marks prior to service bootstrap
      */
-    const marks = performance.getEntriesByType('mark').filter(e => e.name.startsWith(LOADER_MODULE_DEFINE)); // initialize the module define count
+    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
@@ -35,7 +31,7 @@ export class PerformanceApiSink {
     //      - the loader module itself
 
     if (marks.length > 0) {
-      this.instrumentation.incrementCounter(LOADER_MODULE_DEFINE_COUNT, marks.length);
+      this.instrumentation.incrementCounter(MODULE_DEFINE_COUNT, marks.length);
     }
   } // Add observer to log future metrics
   // observe lwr client runtime performance metrics
@@ -43,74 +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_MARK];
+        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(LOADER_MODULE_DEFINE) ? count + 1 : count;
+        return mark.name.startsWith(MODULE_DEFINE) ? count + 1 : count;
       }, 0);
 
       if (moduleDefineCount > 0) {
-        this.instrumentation.incrementCounter(LOADER_MODULE_DEFINE_COUNT, moduleDefineCount);
+        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.9",
+    "version": "0.6.2",
     "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.9",
-        "o11y": "238.1.2"
+        "@lwrjs/shared-utils": "0.6.2",
+        "o11y": "238.1.4"
     },
     "devDependencies": {
         "rollup-plugin-terser": "^7.0.2"
@@ -46,5 +46,5 @@
     "engines": {
         "node": ">=14.15.4 <17"
     },
-    "gitHead": "9cb371a5d01ef345660138a48fe0b3f0119d0799"
+    "gitHead": "ef85bdc48adde58b7c648561d67acbb408bbe189"
 }