# 打造前端监控系统|原理篇

> 本文系统介绍了前端监控系统的核心原理与实现方法，涵盖首屏时间等性能指标的采集方式（手动与自动）、SPA场景下的自动化监控方案（如MutationObserver的应用）、指标权重计算及优化建议，帮助开发者高效搭建和优化前端性能监控体系。

- 原文：https://feinterview.poetries.top/docs/principle-docs/comprehensive/13-%E6%89%93%E9%80%A0%E5%89%8D%E7%AB%AF%E7%9B%91%E6%8E%A7%E7%B3%BB%E7%BB%9F
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.09
- 可见范围：免费部分

---

<!-- principle-learning-suite:start -->
<div class="article-learning-label">文章学习导航</div>

<div class="article-learning-label">面试总览</div>

- 采集围绕错误、性能与关键业务流程
- 标准指标和业务可用时间分别定义
- 页面、版本、请求标识帮助关联证据
- 采样、去重、脱敏控制开销与风险
- 上报成功不等于能定位，要有聚合和有效告警

**前端监控要让线上现象能被还原，而不只是把异常堆到服务端。** 错误需要版本与位置，性能需要设备和页面条件，业务失败还要能关联请求过程。标准浏览器指标尽量用现成定义，单页应用的业务就绪时间另设明确标记。采集代码本身也会消耗资源，要采样、去重和脱敏，再把问题聚合成能判断影响范围的告警。

**版本校准：** 原理文章中的代码代表特定实现与写作时间。应用到当前项目时，应先确认浏览器、框架或工具的主版本，再区分稳定的规范语义、可变化的内部实现和项目自身约束。
<!-- principle-learning-suite:end -->

## 一、性能优化方法论

![](https://s.poetries.top/images/20210502210714.png)

> 首屏时间可以拆分为白屏时间、数据接口响应时间、图片加载资源等

![](https://s.poetries.top/images/20210502214539.png)

![](https://s.poetries.top/images/20210503212926.png)

## 二、指标采集：首屏时间指标采集具体办法

### 手动采集办法及优缺点：

- 所谓手动采集，一般是通过埋点的方式进行， 比如在页面开始位置打上 `FMP.Start()`，在首屏结束位置打上 `FMP.End()`，利用 `FMP.End()-FMP.Start()` 获取到首屏时间。
- 手动采集的统计结果并不精确，因为依赖于人，每个人对首屏的理解有偏差，经常打错或者忘记打点。

### 自动化采集优势及办法

> 所谓自动化采集，即引入一段通用的代码来做首屏时间自动化采集，引入过程中，除了必要的配置不需要做其他事情。

自动化采集的好处是独立性更强，接入过程更自动化。具体的自动化采集代码，可以由一个公共团队来开发，试点后，推广到各个业务团队。而且统计结果更标准化，同一段统计代码，标准更统一，业务侧同学也更认可这个统计结果。

当然，它也有缺点，最明显的是，有些个性化需求无法满足，毕竟在工作中，总会有一些特殊业务场景。所以，采用自动化采集方案必须做一些取舍。

### 单页面（SPA）应用业务下的采集办法

SPA 页面因为无法基于 `DOMContentLoaded` 做首屏指标采集，可以使用 `MutationObserver` 采集首屏时间。

> `MutationObserver` 接口提供了监视对 DOM 树所做更改的能力。它被设计为旧的 `Mutation Events` 功能的替代品，该功能是 DOM3 Events 规范的一部分。

简单来说， 使用 `MutationObserver 能监控页面信息的变化`，当页面 `body` 变化最剧烈的时候，我们拿到的时间数据，就是`首屏时间`。

首先，在用户进入页面时，我们可以使用 `MutationObserver` 监控 `DOM` 元素 （Document Object Model，文档对象模型）。当 DOM 元素发生变化时，程序会标记变化的元素，记录时间点和分数，存储到数组中。数据的格式类似于 `[200ms,18.5]`。

为了提升计算的效率，我们认为首屏指标采集到某些条件时，首屏渲染已经结束，我们需要考虑首屏采集终止的条件，即计算时间超过 30 秒还没有结束；计算了 4 轮且 1 秒内分数不再变化；计算了 9 次且分数不再变化。

接下来，设定元素权重计算分数。

递归遍历 DOM 元素及其子元素，根据子元素所在层数设定元素权重，比如第一层元素权重是 1，当它被渲染时得 1 分，每增加一层权重增加 0.5，比如第五层元素权重是 3.5，渲染时给出对应分数。

为什么需要权重呢？

因为页面中每个 DOM 元素对于首屏的意义是不同的，越往内层越接近真实的首屏内容，如图片和文字，越往外层越接近 body 等框架层。

最后，根据前面的得分，计算元素的分数变化率，获取变化率最大点对应的分数。然后找到该分数对应的时间，即为首屏时间。

分数部分核心计算逻辑是递归遍历元素，将一些无用的标签排除，如果元素超过可视范围返回 0 分，每一层增加 0.5 的权重，具体请看下面代码示例。

```js
function CScor(el, tiers, parentScore) {
    let score = 0;
    const tagName = el.tagName;
    if ("SCRIPT" !== tagName && "STYLE" !== tagName && "META" !== tagName && "HEAD" !== tagName) {
      const childrenLen = el.children ? el.children.length : 0;
      if (childrenLen > 0) for (let childs = el.children, len = childrenLen - 1; len >= 0; len--) {
        score += calculateScore(childs[len], tiers + 1, score > 0);
      }
      if (score <= 0 && !parentScore) {
        if (!(el.getBoundingClientRect && el.getBoundingClientRect().top < WH)) return 0;
      }
      score += 1 + .5 * tiers;
    }
    return score;
  }
```

变化率部分核心计算逻辑是获取 DOM 变化最大时对应的时间，代码如下所示

```js
calFinallScore() {
    try {
      if (this.sendMark) return;
      const time = Date.now() - performance.timing.fetchStart;
      var isCheckFmp = time > 30000 || SCORE_ITEMS && SCORE_ITEMS.length > 4 && time - (SCORE_ITEMS && SCORE_ITEMS.length && SCORE_ITEMS[SCORE_ITEMS.length - 1].t || 0) > 2 * CHECK_INTERVAL || (SCORE_ITEMS.length > 10 && window.performance.timing.loadEventEnd !== 0 && SCORE_ITEMS[SCORE_ITEMS.length - 1].score === SCORE_ITEMS[SCORE_ITEMS.length - 9].score);
      if (this.observer && isCheckFmp) {
        this.observer.disconnect();
        window.SCORE_ITEMS_CHART = JSON.parse(JSON.stringify(SCORE_ITEMS));
        let fmps = getFmp(SCORE_ITEMS);
        let record = null
        for (let o = 1; o < fmps.length; o++) {
          if (fmps[o].t >= fmps[o - 1].t) {
            let l = fmps[o].score - fmps[o - 1].score;
            (!record || record.rate <= l) && (record = {
              t: fmps[o].t,
              rate: l
            });
          }
        }
        //
        this.fmp = record && record.t || 30001;
        try {
          this.checkImgs(document.body)
          let max = Math.max(...this.imgs.map(element => {
            if(/^(\/\/)/.test(element)) element = 'https:' + element;
            try {
              return performance.getEntriesByName(element)[0].responseEnd || 0
            } catch (error) {
              return 0
            }
          }))
          record && record.t > 0 && record.t < 36e5 ? this.setPerformance({
            fmpImg: parseInt(Math.max(record.t , max))
          }) : this.setPerformance({});
        } catch (error) {
          this.setPerformance({});
          // console.error(error)
        }
      } else {
        setTimeout(() => {
          this.calFinallScore();
        }, CHECK_INTERVAL);
      }
    } catch (error) {

    }
  }
```

这个就是首屏计算的部分流程。

看完前面的流程，不知道你有没有这样的疑问：`如果页面里包含图片，使用上面的首屏指标采集方案，结果准确吗`？

> 结论是：不准确。上述计算逻辑主要是针对 DOM元素来做的，图片加载过程是异步，图片容器（图片的 DOM 元素）和内容的加载是分开的，当容器加载出来时，内容还没出来，一定要确保内容加载出来，才算首屏。

这就需要增加一些策略了，以下是包含图片页面的首屏计算 demo。

```html
<!doctype html><body><img id="imgTest" src="https://www.baidu.com/img/bd_logo1.png?where=super">
  <img id="imgTest" src="https://www.baidu.com/img/bd_logo1.png?where=super">
  <style type=text/css>
    background-image:url('https://www.baidu.com/img/dong_8f1d47bcb77d74a1e029d8cbb3b33854.gif);
  </style>
  </body>
  <html>
<script type="text/javascript">
(() => {
  const imgs = []
  const getImageDomSrc = {
    _getImgSrcFromBgImg: function (bgImg) {
      var imgSrc;
      var matches = bgImg.match(/url\(.*?\)/g);
      if (matches && matches.length) {
        var urlStr = matches[matches.length - 1];
        var innerUrl = urlStr.replace(/^url\([\'\"]?/, '').replace(/[\'\"]?\)$/, '');
        if (((/^http/.test(innerUrl) || /^\/\//.test(innerUrl)))) {
          imgSrc = innerUrl;
        }
      }
      return imgSrc;
    },
    getImgSrcFromDom: function (dom, imgFilter) {
      if (!(dom.getBoundingClientRect && dom.getBoundingClientRect().top < window.innerHeight))
        return false;
      imgFilter = [/(\.)(png|jpg|jpeg|gif|webp|ico|bmp|tiff|svg)/i]
      var src;
      if (dom.nodeName.toUpperCase() == 'IMG') {
        src = dom.getAttribute('src');
      } else {
        var computedStyle = window.getComputedStyle(dom);
        var bgImg = computedStyle.getPropertyValue('background-image') || computedStyle.getPropertyValue('background');
        var tempSrc = this._getImgSrcFromBgImg(bgImg, imgFilter);
        if (tempSrc && this._isImg(tempSrc, imgFilter)) {
          src = tempSrc;
        }
      }
      return src;
    },
    _isImg: function (src, imgFilter) {
      for (var i = 0, len = imgFilter.length; i < len; i++) {
        if (imgFilter[i].test(src)) {
          return true;
        }
      }
      return false;
    },
    traverse(e) {
      var _this = this
        , tName = e.tagName;
      if ("SCRIPT" !== tName && "STYLE" !== tName && "META" !== tName && "HEAD" !== tName) {
        var el = this.getImgSrcFromDom(e)
        if (el && !imgs.includes(el))
          imgs.push(el)
        var len = e.children ? e.children.length : 0;
        if (len > 0)
          for (var child = e.children, _len = len - 1; _len >= 0; _len--)
            _this.traverse(child[_len]);
      }
    }
  }
  getImageDomSrc.traverse(document.body);
console.log(imgs,'-imgs--')
  window.onload=function(){
  var max = Math.max(...imgs.map(element => {
     if (/^(\/\/)/.test(element))
      element = 'https:' + element;
    try {
      return performance.getEntriesByName(element)[0].responseEnd || 0
    } catch (error) {
      return 0
    }
  }
  ))
  console.log(max);
  }
}
)()
</script>
```

它的计算逻辑是这样的。

首先，获取页面所有的图片路径。在这里，图片类型分两种，一种是带 IMG 标签的，一种是带 DIV 标签的。前者可以直接通过 src 值得到图片路径，后者可以使用 `window.getComputedStyle(dom)` 方式获取它的样式集合。

接下来，通过正则获取图片的路径即可。

然后通过 `performance.getEntriesByName(element)[0].responseEnd` 的方式获取到对应图片路径的下载时间，最后与使用 `MutationObserver` 获得的 DOM 首屏时间相比较，哪个更长，哪个就是最终的首屏时间。

> 以上就是首屏采集的完整流程

> 注意：计算首屏时间用到的`getBoundingClientRect`和`getComputedStyle`会引起强制回流

![](https://s.poetries.top/images/20210503151137.png)

## 三、指标采集：白屏、卡顿、网络环境指标采集方法

### 白屏指标采集

> 白屏时间是指从输入内容回车（包括刷新、跳转等方式）后，到页面开始出现第一个字符的时间。白屏时间的长短会影响用户对 App 或站点的第一印象

白屏指标怎么采集呢？我们先来回顾一下浏览器的页面加载过程：

> 客户端发起请求 -> 下载 HTML 及 JS/CSS 资源 -> 解析 JS 执行 -> JS 请求数据 -> 客户端解析 DOM 并渲染 -> 下载渲染图片-> 完成渲整体染

在这个过程中，客户端解析 DOM 并渲染之前的时间，都算白屏时间。所以，**白屏时间的采集思路如下**：`白屏时间 = 页面开始展示时间点 - 开始请求时间点`。如果你是借助浏览器的 `Performance API` 工具来采集，那么可以使用公式：`白屏时间 FP` = `domLoading - navigationStart`。

这是浏览器页面加载过程，如果放在 App场景下，就不太一样了，App下的页面加载过程：

> 初始化 WebView -> 客户端发起请求 -> 下载 HTML 及 JS/CSS 资源 -> 解析 JS 执行 -> JS 请求数据 -> 服务端处理并返回数据 -> 客户端解析 DOM 并渲染 -> 下载渲染图片 -> 完成整体渲染。

`App下的白屏时间，多了启动浏览器内核，也就是 Webview 初始化的时间`。这个时间必须通过手动采集的方式来获得，而且因为线上线下时间差别不大，线下采集即可。**具体来说，在 App 测试版本中，程序在 App 创建 WebView 时打一个点，然后在开始建立网络连接打一个点，这两个点的时间差就是 Webview 初始化的时间**。

### 卡顿指标采集

**所谓卡顿，简单来说就是页面出现卡住了的不流畅的情况**。 提到它的指标，你是不是会一下就想到 FPS（Frames Per Second，每秒显示帧数）？FPS 多少算卡顿？网上有很多资料，大多提到 FPS 在 60 以上，页面流畅，不卡顿。但事实上并非如此，比如我们看电影或者动画时，素虽然 FPS 是 30 （低于60），但我们觉得很流畅，并不卡顿。

FPS 低于 60 并不意味着卡顿，那 FPS 高于 60 是否意味着一定不卡顿呢？比如前 60 帧渲染很快（10ms 渲染 1 帧），后面的 3 帧渲染很慢（ 20ms 渲染 1 帧），这样平均起来 FPS 为95，高于 60 的标准。这种情况会不会卡顿呢？实际效果是卡顿的。因为卡顿与否的关键点在于单帧渲染耗时是否过长。

> 但难点在于，在浏览器上，我们没办法拿到单帧渲染耗时的接口，所以这时候，只能拿 FPS 来计算，只要 FPS 保持稳定，且值比较低，就没问题。`它的标准是多少呢？连续 3 帧不低于 20 FPS，且保持恒定`。

以 H5 为例，`H5 场景下获取 FPS 方案如下`：

```js
var fps_compatibility= function () {
    return (
        window.requestAnimationFrame ||
        window.webkitRequestAnimationFrame ||
        function (callback) {
            window.setTimeout(callback, 1000 / 60);
        }
    );
}();
var fps_config={
  lastTime:performance.now(),
  lastFameTime : performance.now(),
  frame:0
}
var fps_loop = function() {
    var _first =  performance.now(),_diff = (_first - fps_config.lastFameTime);
    fps_config.lastFameTime = _first;
    var fps = Math.round(1000/_diff);
    fps_config.frame++;
    if (_first > 1000 + fps_config.lastTime) {
        var fps = Math.round( ( fps_config.frame * 1000 ) / ( _first - fps_config.lastTime ) );
        console.log(`time: ${new Date()} fps is：`, fps);
        fps_config.frame = 0;    
        fps_config.lastTime = _first ;    
    };           
    fps_compatibility(fps_loop);   
}
fps_loop();
function isBlocking(fpsList, below=20, last=3) {
  var count = 0
  for(var i = 0; i < fpsList.length; i++) {
    if (fpsList[i] && fpsList[i] < below) {
      count++;
    } else {
      count = 0
    }
    if (count >= last) {
      return true
    }
  }
  return false
}
```

> 利用 `requestAnimationFrame` 在一秒内执行 `60` 次（在不卡顿的情况下）这一点，假设页面加载用时 `X ms`，这期间 `requestAnimationFrame` 执行了 `N` 次，则帧率为 `1000* N/X`，也就是`FPS`

由于用户客户端差异很大，我们要考虑兼容性，在这里我们定义 `fps_compatibility` 表示兼容性方面的处理，在浏览器不支持 `requestAnimationFrame` 时，利用 `setTimeout` 来模拟实现，在 `fps_loop` 里面完成 FPS 的计算，最终通过遍历 `fpsList` 来判断是否连续三次 fps 小于20。

如果连续判断 3次 FPS 都小于20，就认为是卡顿。

![](https://s.poetries.top/images/20210503152718.png)

## 四、工具实践：性能 SDK 及上报策略设计

由于性能 SDK 最终是给各个业务使用的，所以它的设计要满足在接入性能监控平台时，简单易用和运行平稳高效，这两个要求。

### SDK 接入设计

要保证 `SDK` 接入简单，容易使用，`首先要把之前首屏、白屏和卡顿采集的脚本封装在一起，并让脚本自动初始化和运行`。

![](https://s.poetries.top/images/20210503152937.png)

- 具体来说，首屏采集的`分数计算部分 API（calculateScore）`、`变化率计算的 API（calFinallScore）`和`首屏图片时间计算 API（fmpImg）`可以一起封装成 FMP API。其中首屏图片计算 API 因为比较独立，可以专门抽离成一个 util，供其他地方调用。白屏和卡顿采集也类似，可以封装成 `FP API` 和 `BLOCK API`。
- 还有一个 `ExtensionAPI` 接口，用来封装一些后续需要使用的数据，比如加载瀑布流相关的数据（将首屏时间细分为DNS、TCP连接等时间），这些数据可以通过浏览器提供的 `performance` 接口获得。

> 为了进行首屏、白屏、卡顿的指标采集，我们可以封装 `Perf API`，调用 `FMP、FP、BLOCK、ExtensionAPI` 四个 API 来完成。因为是调用 `window.performance` 接口，所以先做环境兼容性的判断，即看看浏览器是否支持 `window.performance`

最终我们接入时只要安装一个 `npm` 包，然后初始化即可，具体代码如下：

```js
 npm install @common/Perf -S;
 import { perfInit } from '@common';
 perfInit ();
```

或者以外链的形式接入：

```js
<script type="text/javascript">https://s1.static.com/common/perf/static/js/1.0.0/perf.min.js</script>
try {
  perfInit ();
} catch (err) {
  console.warn(err);
}
```

除了性能 SDK 自身的方案设计之外，提供帮助文档（如示例代码、 QA 列表等），也可以提高性能 SDK 的易用性。

具体来说，我们可以搭建一个简单的性能 SDK 网站，进入站点后，前端工程师可以看到使用文档，包括各种平台下如何接入，接入的示例代码是怎样的，接入性能 SDK 后去哪个 URL 看数据，遇到异常问题时怎么调试，等等。

### SDK 运行设计

SDK 如果想运行高效，必须有好的兼容性策略、容错机制和测试方案。

所谓兼容性策略，就是性能 SDK 可以在各个业务下都可以稳定运行。

**我们知道，前端性能优化会面临的业务场景大致有：**

- 各类页面，如平台型页面、3C 类页面、中后台页面；
- 一些可视化搭建的平台，如用于搭建天猫双十一会场页这种用于交易运行页面的魔方系统；
- 各个终端，如 PC 端，移动端，小程序端等。

这就要求性能 SDK 要能适应这些业务，及时采集性能指标并进行上报。那具体怎么做呢？

一般不同页面和终端，它们的技术栈也会不同，如 PC端页面使用 React，移动端页面使用 VUE 。这个时候，`我们可以尽可能用原生 JavaScript 去做性能指标的采集，从而实现跨不同技术栈的采集`。

> 不同终端方面，我设计了一个适配层来抹平采集方面的差异。`具体来说，小程序端可以用有自己的采集 API，如 minaFMP`，`其他端可以直接用 FMP`，这样在性能 SDK 初始化时，`根据当前终端类型的不同，去调用各自的性能指标采集 API`。

容错方面怎么做呢？

> 如果是性能 SDK 自身的报错，可以通过 `try catch` 的方式捕获到，然后上报异常监控平台。注意，不要因为 SDK 的报错而影响引入性能 SDK 页面的正常运行。

### 日志数据过滤

我的建议是，在采集性能指标之后，最好先对异常数据进行过滤。

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/principle-docs/comprehensive/13-%E6%89%93%E9%80%A0%E5%89%8D%E7%AB%AF%E7%9B%91%E6%8E%A7%E7%B3%BB%E7%BB%9F
