@adobe/spacecat-shared-rum-api-client 2.12.6 → 2.13.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [@adobe/spacecat-shared-rum-api-client-v2.13.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-rum-api-client-v2.12.6...@adobe/spacecat-shared-rum-api-client-v2.13.0) (2024-11-28)
+
+
+### Features
+
+* Introduce configurable grouping patterns ([#458](https://github.com/adobe/spacecat-shared/issues/458)) ([6414b13](https://github.com/adobe/spacecat-shared/commit/6414b13ccffdf567460efddb019f8f3de0200b5a))
+
 # [@adobe/spacecat-shared-rum-api-client-v2.12.6](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-rum-api-client-v2.12.5...@adobe/spacecat-shared-rum-api-client-v2.12.6) (2024-11-27)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-rum-api-client",
-  "version": "2.12.6",
+  "version": "2.13.0",
   "description": "Shared modules of the Spacecat Services - Rum API client",
   "type": "module",
   "engines": {

package/src/functions/cwv.js

@@ -13,37 +13,144 @@
 import {
   DataChunks, series, facets,
 } from '@adobe/rum-distiller';
-import { loadBundles } from '../utils.js';
+import { generateKey, DELIMITER, loadBundles } from '../utils.js';
 
-function handler(bundles) {
-  const dataChunks = new DataChunks();
+const METRICS = ['lcp', 'cls', 'inp', 'ttfb'];
+
+const USER_AGENT_DELIMITER = ':';
+
+const FACET_TYPE = {
+  GROUP: 'group',
+  URL: 'url',
+};
+
+const findMatchedPattern = (url, urlPatterns) => {
+  for (const urlPattern of urlPatterns) {
+    const regex = new RegExp(`^${urlPattern.pattern.replace(/\*/g, '.*')}$`);
+    if (regex.test(url)) {
+      return urlPattern;
+    }
+  }
+  return null;
+};
+
+const mapUrlsToPatterns = (bundles, patterns) => {
+  const urlToPatternMap = {};
+  if (!patterns || patterns.length === 0) {
+    return urlToPatternMap;
+  }
 
+  for (const bundle of bundles) {
+    const matchedPattern = findMatchedPattern(bundle.url, patterns);
+
+    if (matchedPattern) {
+      // Check if any cwv metric exists in bundle.events
+      const hasMetrics = bundle.events.some((event) => METRICS.some((metric) => event.checkpoint.includes(`cwv-${metric}`)));
+
+      if (hasMetrics) {
+        urlToPatternMap[bundle.url] = matchedPattern;
+      }
+    }
+  }
+  return urlToPatternMap;
+};
+
+const calculateMetricsPercentile = (metrics) => ({
+  lcp: metrics.lcp.percentile(75) || null,
+  lcpCount: metrics.lcp.count || 0,
+  cls: metrics.cls.percentile(75) || null,
+  clsCount: metrics.cls.count || 0,
+  inp: metrics.inp.percentile(75) || null,
+  inpCount: metrics.inp.count || 0,
+  ttfb: metrics.ttfb.percentile(75) || null,
+  ttfbCount: metrics.ttfb.count || 0,
+});
+
+function handler(rawBundles, opts = []) {
+  const bundles = rawBundles.map((bundle) => ({
+    ...bundle,
+    url: facets.url(bundle), // URL without ids, hashes, and other encoded data
+  }));
+  const urlToPatternMap = mapUrlsToPatterns(bundles, opts.groupedURLs);
+
+  const dataChunks = new DataChunks();
   loadBundles(bundles, dataChunks);
 
-  dataChunks.addFacet('urls', facets.url);
-
-  dataChunks.addSeries('lcp', series.lcp);
-  dataChunks.addSeries('cls', series.cls);
-  dataChunks.addSeries('inp', series.inp);
-  dataChunks.addSeries('ttfb', series.ttfb);
-
-  return dataChunks.facets.urls.map((urlFacet) => ({
-    url: urlFacet.value,
-    pageviews: urlFacet.weight,
-    lcp: urlFacet.metrics.lcp.percentile(75) || null,
-    lcpCount: urlFacet.metrics.lcp.count,
-    cls: urlFacet.metrics.cls.percentile(75) || null,
-    clsCount: urlFacet.metrics.cls.count,
-    inp: urlFacet.metrics.inp.percentile(75) || null,
-    inpCount: urlFacet.metrics.inp.count,
-    ttfb: urlFacet.metrics.ttfb.percentile(75) || null,
-    ttfbCount: urlFacet.metrics.ttfb.count,
-  }))
-    .filter((row) => row.lcp || row.cls || row.inp || row.ttfb) // filter out pages with no cwv data
-    .sort((a, b) => b.pageviews - a.pageviews); // sort desc by pageviews
+  // groups by url and device
+  dataChunks.addFacet(
+    'urlsDevices',
+    (bundle) => generateKey(bundle.url, bundle.userAgent.split(USER_AGENT_DELIMITER)[0]),
+  );
+
+  // groups by pattern and device
+  dataChunks.addFacet('patternsDevices', (bundle) => {
+    const device = bundle.userAgent.split(USER_AGENT_DELIMITER)[0];
+    return urlToPatternMap[bundle.url]?.pattern
+      ? generateKey(urlToPatternMap[bundle.url].pattern, device)
+      : null;
+  });
+
+  // counts metrics per each facet
+  METRICS.forEach((metric) => dataChunks.addSeries(metric, series[metric]));
+
+  const patternsResult = dataChunks.facets.patternsDevices.reduce((acc, facet) => {
+    const [pattern, deviceType] = facet.value.split(DELIMITER);
+    const patternData = Object.values(urlToPatternMap).find((p) => p.pattern === pattern);
+
+    acc[pattern] = acc[pattern] || {
+      type: FACET_TYPE.GROUP,
+      name: patternData.name,
+      pattern,
+      pageviews: 0,
+      metrics: [],
+    };
+
+    // Increment the total pageviews for pattern
+    acc[pattern].pageviews += facet.weight;
+
+    // Add metrics for the specific device type
+    acc[pattern].metrics.push({
+      deviceType,
+      pageviews: facet.weight, // Pageviews for this device type
+      ...calculateMetricsPercentile(facet.metrics),
+    });
+
+    return acc;
+  }, {});
+
+  const urlsResult = dataChunks.facets.urlsDevices.reduce((acc, facet) => {
+    const [url, deviceType] = facet.value.split(DELIMITER);
+
+    acc[url] = acc[url] || {
+      type: FACET_TYPE.URL,
+      url,
+      pageviews: 0,
+      metrics: [],
+    };
+
+    // Increment the total pageviews for url
+    acc[url].pageviews += facet.weight;
+
+    // Add metrics for the specific device type
+    acc[url].metrics.push({
+      deviceType,
+      pageviews: facet.weight, // Pageviews for this device type
+      ...calculateMetricsPercentile(facet.metrics),
+    });
+
+    return acc;
+  }, {});
+
+  const result = [...Object.values(patternsResult), ...Object.values(urlsResult)]
+    // filter out pages with no cwv data
+    .filter((row) => METRICS.some((metric) => row.metrics.some((entry) => entry[metric])))
+    // sort desc by pageviews
+    .sort((a, b) => b.metrics.pageviews - a.metrics.pageviews);
+
+  return result;
 }
 
 export default {
   handler,
-  checkpoints: ['cwv-lcp', 'cwv-cls', 'cwv-inp', 'cwv-ttfb'],
+  checkpoints: METRICS.map((metric) => `cwv-${metric}`),
 };

package/src/index.d.ts

@@ -17,6 +17,10 @@ export interface RUMAPIOptions {
     domainkey: string;
     interval?: number;
     granularity?: 'hourly' | 'daily';
+    groupedURLs?: Array<{
+      name: string;
+      pattern: string;
+    }>;
 }
 
 export default class RUMAPIClient {

package/src/index.js

@@ -52,7 +52,7 @@ export default class RUMAPIClient {
         checkpoints,
       });
 
-      return handler(bundles);
+      return handler(bundles, opts);
     } catch (e) {
       throw new Error(`Query '${query}' failed. Opts: ${JSON.stringify(opts)}. Reason: ${e.message}`);
     }