[临窗旋墨]javaMelody初始化以及销毁时的处理逻辑及监控日志丢失问题排查

文章来源：原创   作者：许秋冬   发布时间：2020-11-03   阅读：3609   标签：源码 分类：第三方包 专题：我读[不懂]源码

[toc]

[临窗旋墨]javaMelody初始化以及销毁时的处理逻辑及监控日志丢失问题排查

一 javaMelody销毁时的处理逻辑

在MonitoringFilter调用destroy销毁的方法中,主要调用的方法:FilterContext#destroy

在过滤器上下文销毁的时候,调用了collector.stop();即停止计数器,

在停止计数器的时候, 会把计数器信息序列化到对应的.ser.gz文件中;

MonitoringFilter#destroy

  1. public void destroy() {
  2.         if (monitoringDisabled || !instanceEnabled) {
  3.             return;
  4.         }
  5.         final long start = System.currentTimeMillis();
  7.         try {
  8.             if (filterContext != null) {
  9.                 //过滤器上下文销毁 ,参见下文代码0
  10.                 filterContext.destroy();
  11.             }
  12.         } finally {
  13.             final String contextPath = Parameters.getContextPath(filterConfig.getServletContext());
  14.             CONTEXT_PATHS.remove(contextPath);
  15.             // 把一些变量置为空 代码略
  16.         }
  17.         final long duration = System.currentTimeMillis() - start;
  18.         LOG.debug("JavaMelody filter destroy done in " + duration + " ms");

FilterContext#destroy

  1. void destroy() {
  2.     try {
  3.         try {
  4.             if (collector != null) {
  5.                 // 写入相关信息到监控目录下的last_shutdown.html文件里
  6.                 new MonitoringController(collector, null).writeHtmlToLastShutdownFile();
  7.             }
  8.         } finally {
  9.             //停止并注销jdbc wrapper
  10.             JdbcWrapper.SINGLETON.stop();
  11.             //销毁jdbcDriver
  12.             deregisterJdbcDriver();
  14.             // 移除logging
  15.             deregisterLogs();
  17.             // 销毁定时器
  18.             if (JobInformations.QUARTZ_AVAILABLE) {
  19.                 JobGlobalListener.destroyJobGlobalListener();
  20.             }
  21.             //注销CounterRequestMXBean bean。
  22.             unregisterJmxExpose();
  23.         }
  24.     } finally {
  25.         MonitoringInitialContextFactory.stop();
  27.         // 定时器清除
  28.         if (timer != null) {
  29.             timer.cancel();
  30.         }
  31.         // 应该是停止采集cpu的一些东西
  32.         if (samplingProfiler != null) {
  33.             samplingProfiler.clear();
  34.         }
  35.         // 停止计数器, 但是在停止之前会把计数器写到文件 参见下文代码
  36.         if (collector != null) {
  37.             collector.stop();
  38.         }
  39.         // 调用的是JRobin.stop(); Robin注释:RRD存储和统计图表.....
  40.         Collector.stopJRobin();
  41.         //JVM的一些监控统计
  42.         Collector.detachVirtualMachine();
  43.     }
  44. }

Collector#stop

  1.     public void stop() {
  2.         try {
  3.             try {
  4.                 for (final Counter counter : counters) {
  5.                     // 写入到这样的一个文件里:
  6.                     //new File(storageDirectory, counter.getStorageName() + ".ser.gz");
  7.                     //写入的时候用的时候 ObjectOutputStream  也即直接把对象序列化到文件中
  8.                     counter.writeToFile();
  9.                 }
  10.             } finally {
  11.                 storageLock.release();
  12.             }
  13.         } catch (final IOException e) {
  14.             // persistance échouée, tant pis
  15.             LOG.warn("exception while writing counters data to files", e);
  16.         } finally {
  17.             try {
  18.                 for (final Counter counter : counters) {
  19.                     counter.clear();
  20.                 }
  21.             } finally {
  22.                 if (metricsPublishers != null) {
  23.                     for (final MetricsPublisher metricsPublisher : metricsPublishers) {
  24.                         metricsPublisher.stop();
  25.                     }
  26.                 }
  27.             }
  28.             stopped = true;
  29.             // 一串看不懂的注释...................
  30.             // ici on ne fait pas de nettoyage de la liste counters car cette méthode
  31.             // est appelée sur la webapp monitorée quand il y a un serveur de collecte
  32.             // et que cette liste est envoyée au serveur de collecte,
  33.             // et on ne fait pas de nettoyage des maps qui servent dans le cas
  34.             // où le monitoring de la webapp monitorée est appelée par un navigateur
  35.             // directement même si il y a par ailleurs un serveur de collecte
  36.             // (dans ce dernier cas les données sont bien sûr partielles)
  37.         }
  38.     }

二 javaMelody初始化处理逻辑

代码太长,只粗略的浏览部分代码链

  1. 在MonitoringFilter#init中初始化过滤器上下文FilterContext,非常重要的一段代码
  2. FilterContext构造代码中,几个重要的逻辑:
    1. initCounters(); 初始化各种计数器
    2. 构造Collector对象,从文件中读取各个计数器的信息
    3. CollectTimerTask 新建收集器的定时任务, 这个定时器 为把收集到的信息写到文件★★★★★★★

MonitoringFilter#init

  1. public void init(FilterConfig config) throws ServletException {
  2.         final long start = System.currentTimeMillis(); // NOPMD
  3.         final String contextPath = Parameters.getContextPath(config.getServletContext());
  4.         if (!instanceEnabled) {
  5.             if (!CONTEXT_PATHS.contains(contextPath)) {
  6.                 instanceEnabled = true;
  7.             } else {
  8.                 return;
  9.             }
  10.         }
  11.         CONTEXT_PATHS.add(contextPath);
  12.         this.filterConfig = config;
  13.         this.servletApi2 = config.getServletContext().getMajorVersion() < 3;
  14.         Parameters.initialize(config);
  15.         monitoringDisabled = Parameter.DISABLED.getValueAsBoolean();
  16.         if (monitoringDisabled) {
  17.             return;
  18.         }
  20.         LOG.debug("JavaMelody filter init started");
  21.         // 初始化过滤器上下文,非常重要的一段代码 ★★★★★ 见下文代码
  22.         this.filterContext = new FilterContext(getApplicationType());
  23.         this.httpAuth = new HttpAuth();
  24.         config.getServletContext().setAttribute(ReportServlet.FILTER_CONTEXT_KEY, filterContext);
  25.         final Collector collector = filterContext.getCollector();
  26.         this.httpCounter = collector.getCounterByName(Counter.HTTP_COUNTER_NAME);
  27.         this.errorCounter = collector.getCounterByName(Counter.ERROR_COUNTER_NAME);
  29.         logEnabled = Parameter.LOG.getValueAsBoolean();
  30.         rumEnabled = Parameter.RUM_ENABLED.getValueAsBoolean();
  31.         if (Parameter.URL_EXCLUDE_PATTERN.getValue() != null) {
  33.         urlExcludePattern = Pattern.compile(Parameter.URL_EXCLUDE_PATTERN.getValue());
  34.         }    
  35.     }

FilterContext 构造器

  1.     FilterContext(final String applicationType) {
  2.         super();
  3.         assert applicationType != null;
  4.         this.applicationType = applicationType;
  6.         boolean initOk = false;
  7.         // 新建守护进程的定时器
  8.         this.timer = new Timer("javamelody"
  9.                 + Parameters.getContextPath(Parameters.getServletContext()).replace('/', ' '),
  10.                 true);
  11.         try {
  12.             //打印一些系统信息和参数
  13.             logSystemInformationsAndParameters();
  14.             //初始化log相关, 判断使用的是哪种log,然后注册
  15.             initLogs();
  17.             //初始化MonitoringInitialContextFactory, 就是一个System.setProperty动作
  18.             if (Parameter.CONTEXT_FACTORY_ENABLED.getValueAsBoolean()) {
  19.                 MonitoringInitialContextFactory.init();
  20.             }
  22.             //大概就是包裹jdbc,使之能够监控到sql
  23.             JdbcWrapper.SINGLETON.initServletContext(Parameters.getServletContext());
  24.             if (!Parameters.isNoDatabase()) {
  25.                 JdbcWrapper.SINGLETON.rebindDataSources();
  26.             } else {
  28.                 JdbcWrapper.SINGLETON.stop();
  29.             }
  31.             if (JobInformations.QUARTZ_AVAILABLE) {
  32.                 JobGlobalListener.initJobGlobalListener();
  33.             }
  35.             if (MOJARRA_AVAILABLE) {
  36.                 JsfActionHelper.initJsfActionListener();
  37.             }
  38.             if (JPA2_AVAILABLE) {
  39.                 JpaPersistence.initPersistenceProviderResolver();
  40.             }
  41.             // 初始化 samplingProfiler:通过定期采样线程的堆栈跟踪来检测CPU热点CPU。
  42.             //里面是一个定时器每10s执行一次sampler.update();
  43.             this.samplingProfiler = initSamplingProfiler();
  44.             //初始化各种计数器 非常重要★★★★★ 参见下文代码
  45.             final List<Counter> counters = initCounters();
  46.             final String application = Parameters.getCurrentApplication();
  47.             // ★★★★★★这个构造函数代码比较长, 其中有个重要的逻辑就是
  48.             // 从文件中反序列化出每个计数器, 以及初始化 当前日期的计数器
  49.             this.collector = new Collector(application, counters, this.samplingProfiler);
  50.             // 新建收集器的定时任务, 这个定时器 为把收集到的信息写到文件★★★★★★★(代码太长 略)
  51.             this.collectTimerTask = new CollectTimerTask(collector);
  52.             //初始化 收集器,开启collectTimerTask  
  53.             // 使用自己的文件同步Timer 操作相关Rrd
  54.             initCollect();
  56.             if (Parameter.JMX_EXPOSE_ENABLED.getValueAsBoolean()) {
  57.                 initJmxExpose();
  58.             }
  59.            //检测melody版本? 定时器 10分钟后执行 每24小时执行一次
  60.             UpdateChecker.init(timer, collector, applicationType);
  62.             if (Parameters.getServletContext().getServerInfo().contains("Google App Engine")) {
  63.                 // https://issuetracker.google.com/issues/72216727
  64.                 final String fontConfig = System.getProperty("java.home")
  65.                         + "/lib/fontconfig.Prodimage.properties";
  66.                 if (new File(fontConfig).exists()) {
  67.                     System.setProperty("sun.awt.fontconfig", fontConfig);
  68.                 }
  69.             }
  71.             initOk = true;
  72.         } finally {
  73.             if (!initOk) {
  74.                 // si exception dans initialisation, on annule la création du timer
  75.                 // (sinon tomcat ne serait pas content)
  76.                 timer.cancel();
  77.                 LOG.debug("JavaMelody init failed");
  78.             }
  79.         }
  80.     }

FilterContext#initCounters

  1. private static List<Counter> initCounters() {
  2.         final Counter sqlCounter = JdbcWrapper.SINGLETON.getSqlCounter();
  3.         final Counter httpCounter = new Counter(Counter.HTTP_COUNTER_NAME, "dbweb.png", sqlCounter);
  4.         final Counter errorCounter = new Counter(Counter.ERROR_COUNTER_NAME, "error.png");
  5.         errorCounter.setMaxRequestsCount(250);
  7.         final Counter jpaCounter = MonitoringProxy.getJpaCounter();
  8.         final Counter ejbCounter = MonitoringProxy.getEjbCounter();
  9.         final Counter springCounter = MonitoringProxy.getSpringCounter();
  10.         final Counter guiceCounter = MonitoringProxy.getGuiceCounter();
  11.         final Counter servicesCounter = MonitoringProxy.getServicesCounter();
  12.         final Counter strutsCounter = MonitoringProxy.getStrutsCounter();
  13.         final Counter jsfCounter = MonitoringProxy.getJsfCounter();
  14.         final Counter logCounter = LoggingHandler.getLogCounter();
  15.         final Counter jspCounter = JspWrapper.getJspCounter();
  16.         final List<Counter> counters;
  17.         if (JobInformations.QUARTZ_AVAILABLE) {
  18.             final Counter jobCounter = JobGlobalListener.getJobCounter();
  19.             counters = Arrays.asList(httpCounter, sqlCounter, jpaCounter, ejbCounter, springCounter,
  20.                     guiceCounter, servicesCounter, strutsCounter, jsfCounter, jspCounter,
  21.                     errorCounter, logCounter, jobCounter);
  22.         } else {
  23.             counters = Arrays.asList(httpCounter, sqlCounter, jpaCounter, ejbCounter, springCounter,
  24.                     guiceCounter, servicesCounter, strutsCounter, jsfCounter, jspCounter,
  25.                     errorCounter, logCounter);
  26.         }
  27.         //设置每个计数器对应的查询正则表达式    
  28.         setRequestTransformPatterns(counters);
  29.         final String displayedCounters = Parameter.DISPLAYED_COUNTERS.getValue();
  30.         if (displayedCounters == null) {
  31.             // 默认情况下，将显示HTTP、SQL、Error和Log（（和使用的）计数器。
  32.             httpCounter.setDisplayed(true);
  33.             sqlCounter.setDisplayed(!Parameters.isNoDatabase());
  34.             errorCounter.setDisplayed(true);
  35.             logCounter.setDisplayed(true);
  36.             jpaCounter.setDisplayed(jpaCounter.isUsed());
  37.             ejbCounter.setDisplayed(ejbCounter.isUsed());
  38.             springCounter.setDisplayed(springCounter.isUsed());
  39.             guiceCounter.setDisplayed(guiceCounter.isUsed());
  40.             servicesCounter.setDisplayed(servicesCounter.isUsed());
  41.             strutsCounter.setDisplayed(strutsCounter.isUsed());
  42.             jsfCounter.setDisplayed(jsfCounter.isUsed());
  43.             jspCounter.setDisplayed(jspCounter.isUsed());
  44.         } else {
  45.             setDisplayedCounters(counters, displayedCounters);
  46.         }
  47.         LOG.debug("counters initialized");
  48.         return counters;
  49.     }

Collector构造函数

去掉

  1. public Collector(String application, List<Counter> counters,
  2.             SamplingProfiler samplingProfiler) {
  3.         super();
  4.         assert application != null;
  5.         assert counters != null;
  6.         this.application = application;
  7.         this.counters = Collections.unmodifiableList(new ArrayList<Counter>(counters));
  8.         this.samplingProfiler = samplingProfiler;
  9.         for (final Counter counter : counters) {
  10.             for (final Counter otherCounter : counters) {
  11.                 assert counter == otherCounter || !counter.getName().equals(otherCounter.getName());
  12.             }
  13.             counter.setApplication(application);
  14.             final Counter dayCounter = new PeriodCounterFactory(counter)
  15.                     .createDayCounterAtDate(new Date());
  16.             dayCountersByCounter.put(counter, dayCounter);
  17.         }
  18.         periodMillis = Parameters.getResolutionSeconds() * 1000;
  20.         try {
  21.             //反序列化计数器
  22.             for (final Counter counter : counters) {
  23.                 counter.readFromFile();
  24.             }
  25.             // 反序列化当前日期的计数器
  26.             for (final Counter counter : counters) {
  27.                 dayCountersByCounter.get(counter).readFromFile();
  28.             }
  29.             LOG.debug("counters data read from files in "
  30.                     + Parameters.getStorageDirectory(application));
  31.         } catch (final IOException e) {
  33.             LOG.warn("exception while reading counters data from files in "
  34.                     + Parameters.getStorageDirectory(application), e);
  35.         }
  36.         this.storageLock = new StorageLock(application);
  37.         this.webappVersions = new WebappVersions(application);
  38.     }

曾遇到的部分监控数据丢失的问题：

  1. 一个Counter 对应一个计数器,对应一个磁盘上的.ser.gz格式的压缩文件(是一个序列化的javaBean:Counter)
  2. 一个Counter中包含一个查询数列表requests;
  3. 通过代码可知, 当一个计数器中的查询列表超过一万条以后,再次往计数机中插入查询信息的时候,就会删除点击数少于10的查询记录;

Counter#addRequestsAndErrors部分代码摘录

  1. void addRequestsAndErrors(Counter newCounter) {
  2.         assert getName().equals(newCounter.getName());
  4.         for (final CounterRequest newRequest : newCounter.getRequests()) {
  5.             if (newRequest.getHits() > 0) {
  6.                 final CounterRequest request = getCounterRequestInternal(newRequest.getName());
  7.                 synchronized (request) {
  8.                     request.addHits(newRequest);
  9.                 }
  10.             }
  11.         }
  13.         int size = requests.size();
  14.        // 默认最大10000
  15.         final int maxRequests = getMaxRequestsCount();
  16.         if (size > maxRequests) {
  17.             //如果查询次数超过10000次（例如，SQL没有被复制）。
  18.             //我们在这里尝试避免使记忆饱和（）和硬盘饱和
  19.             //在所有这些不同的申请中，删除不到10个HITS的申请。
  20.             //（（例如，对工厂内每年的聚合有用）
  21.             //根据一个新的查询，因为这将由集合类完成
  22.             for (final CounterRequest request : requests.values()) {
  23.                 if (request.getHits() < 10) {
  24.                     removeRequest(request.getName());
  25.                     size--;
  26.                     if (size <= maxRequests) {
  27.                         break;
  28.                     }
  29.                 }
  30.             }
  31.         }
  33.         if (isErrorCounter()) {
  34.             addErrors(newCounter.getErrors());
  35.         }
  36.     }

基于我对javamelody的了解非常有限，我觉得作者设计的大于一万条之后的清理逻辑应该是出于对内存的考虑吧， 因为，曾在测试环境，由于长时间未清理监控日志文件，在javamelody启动时候大概占用200M内存，若不限制的追加，还是有造成内存泄漏的可能的。

​ 所以，我个人建议在一段时间之后可以尝试清理javamelody的监控日志文件（在关闭服务后清理）。

发表评论

目录