#9678

pending completion

Build # #9678

Build Type

push

travis_ci

Committed by

web-flow

Commit Message

add iotdb-doap.rdf back (#10685)

Run Details

79139 of 164854 relevant lines covered (48.01%)

0.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

11.49

/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/concurrent/ThreadPoolMetrics.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.iotdb.commons.concurrent;

import org.apache.iotdb.commons.concurrent.threadpool.IThreadPoolMBean;
import org.apache.iotdb.metrics.AbstractMetricService;
import org.apache.iotdb.metrics.metricsets.IMetricSet;
import org.apache.iotdb.metrics.utils.MetricLevel;
import org.apache.iotdb.metrics.utils.MetricType;
import org.apache.iotdb.metrics.utils.SystemMetric;
import org.apache.iotdb.metrics.utils.SystemTag;

import java.util.HashMap;
import java.util.Map;

@SuppressWarnings("java:S6548")
public class ThreadPoolMetrics implements IMetricSet {
  private AbstractMetricService metricService;
  private Map<String, IThreadPoolMBean> notRegisteredPoolMap = new HashMap<>();
  private Map<String, IThreadPoolMBean> registeredPoolMap = new HashMap<>();

  public static ThreadPoolMetrics getInstance() {
    return ThreadPoolMetricsHolder.INSTANCE;
  }

  private ThreadPoolMetrics() {}

  public void registerThreadPool(IThreadPoolMBean pool, String name) {
    synchronized (this) {
      if (metricService == null) {
        notRegisteredPoolMap.put(name, pool);
      } else {
        registeredPoolMap.put(name, pool);
        metricService.createAutoGauge(
            SystemMetric.THREAD_POOL_ACTIVE_THREAD_COUNT.toString(),
            MetricLevel.IMPORTANT,
            registeredPoolMap,
            map -> registeredPoolMap.get(name).getActiveCount(),
            SystemTag.POOL_NAME.toString(),
            name);
        metricService.createAutoGauge(
            SystemMetric.THREAD_POOL_CORE_SIZE.toString(),
            MetricLevel.IMPORTANT,
            registeredPoolMap,
            map -> registeredPoolMap.get(name).getCorePoolSize(),
            SystemTag.POOL_NAME.toString(),
            name);
        metricService.createAutoGauge(
            SystemMetric.THREAD_POOL_WAITING_TASK_COUNT.toString(),
            MetricLevel.IMPORTANT,
            registeredPoolMap,
            map -> registeredPoolMap.get(name).getQueueLength(),
            SystemTag.POOL_NAME.toString(),
            name);
        metricService.createAutoGauge(
            SystemMetric.THREAD_POOL_DONE_TASK_COUNT.toString(),
            MetricLevel.IMPORTANT,
            registeredPoolMap,
            map -> registeredPoolMap.get(name).getCompletedTaskCount(),
            SystemTag.POOL_NAME.toString(),
            name);
        metricService.createAutoGauge(
            SystemMetric.THREAD_POOL_LARGEST_POOL_SIZE.toString(),
            MetricLevel.IMPORTANT,
            registeredPoolMap,
            map -> registeredPoolMap.get(name).getLargestPoolSize(),
            SystemTag.POOL_NAME.toString(),
            name);
      }
    }
  }

  @Override
  public void bindTo(AbstractMetricService metricService) {
    synchronized (this) {
      this.metricService = metricService;
      for (Map.Entry<String, IThreadPoolMBean> entry : notRegisteredPoolMap.entrySet()) {
        metricService.createAutoGauge(
            SystemMetric.THREAD_POOL_ACTIVE_THREAD_COUNT.toString(),
            MetricLevel.IMPORTANT,
            registeredPoolMap,
            map -> entry.getValue().getActiveCount(),
            SystemTag.POOL_NAME.toString(),
            entry.getKey());
        metricService.createAutoGauge(
            SystemMetric.THREAD_POOL_CORE_SIZE.toString(),
            MetricLevel.IMPORTANT,
            registeredPoolMap,
            map -> entry.getValue().getCorePoolSize(),
            SystemTag.POOL_NAME.toString(),
            entry.getKey());
        metricService.createAutoGauge(
            SystemMetric.THREAD_POOL_WAITING_TASK_COUNT.toString(),
            MetricLevel.IMPORTANT,
            registeredPoolMap,
            map -> entry.getValue().getQueue().size(),
            SystemTag.POOL_NAME.toString(),
            entry.getKey());
        metricService.createAutoGauge(
            SystemMetric.THREAD_POOL_DONE_TASK_COUNT.toString(),
            MetricLevel.IMPORTANT,
            registeredPoolMap,
            map -> entry.getValue().getCompletedTaskCount(),
            SystemTag.POOL_NAME.toString(),
            entry.getKey());
        metricService.createAutoGauge(
            SystemMetric.THREAD_POOL_LARGEST_POOL_SIZE.toString(),
            MetricLevel.IMPORTANT,
            registeredPoolMap,
            map -> entry.getValue().getLargestPoolSize(),
            SystemTag.POOL_NAME.toString(),
            entry.getKey());
      }
      registeredPoolMap.putAll(notRegisteredPoolMap);
      notRegisteredPoolMap.clear();
    }
  }

  @Override
  public void unbindFrom(AbstractMetricService metricService) {
    for (Map.Entry<String, IThreadPoolMBean> entry : registeredPoolMap.entrySet()) {
      metricService.remove(
          MetricType.GAUGE,
          SystemMetric.THREAD_POOL_ACTIVE_THREAD_COUNT.toString(),
          SystemTag.POOL_NAME.toString(),
          entry.getKey());
      metricService.remove(
          MetricType.GAUGE,
          SystemMetric.THREAD_POOL_CORE_SIZE.toString(),
          SystemTag.POOL_NAME.toString(),
          entry.getKey());
      metricService.remove(
          MetricType.GAUGE,
          SystemMetric.THREAD_POOL_WAITING_TASK_COUNT.toString(),
          SystemTag.POOL_NAME.toString(),
          entry.getKey());
      metricService.remove(
          MetricType.GAUGE,
          SystemMetric.THREAD_POOL_DONE_TASK_COUNT.toString(),
          SystemTag.POOL_NAME.toString(),
          entry.getKey());
      metricService.remove(
          MetricType.GAUGE,
          SystemMetric.THREAD_POOL_LARGEST_POOL_SIZE.toString(),
          SystemTag.POOL_NAME.toString(),
          entry.getKey());
    }
  }

  private static class ThreadPoolMetricsHolder {
    private static final ThreadPoolMetrics INSTANCE = new ThreadPoolMetrics();

    private ThreadPoolMetricsHolder() {}
  }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one
3	* or more contributor license agreements. See the NOTICE file
4	* distributed with this work for additional information
5	* regarding copyright ownership. The ASF licenses this file
6	* to you under the Apache License, Version 2.0 (the
7	* "License"); you may not use this file except in compliance
8	* with the License. You may obtain a copy of the License at
9	*
10	* http://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing,
13	* software distributed under the License is distributed on an
14	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15	* KIND, either express or implied. See the License for the
16	* specific language governing permissions and limitations
17	* under the License.
18	*/
19
20	package org.apache.iotdb.commons.concurrent;
21
22	import org.apache.iotdb.commons.concurrent.threadpool.IThreadPoolMBean;
23	import org.apache.iotdb.metrics.AbstractMetricService;
24	import org.apache.iotdb.metrics.metricsets.IMetricSet;
25	import org.apache.iotdb.metrics.utils.MetricLevel;
26	import org.apache.iotdb.metrics.utils.MetricType;
27	import org.apache.iotdb.metrics.utils.SystemMetric;
28	import org.apache.iotdb.metrics.utils.SystemTag;
29
30	import java.util.HashMap;
31	import java.util.Map;
32
33	@SuppressWarnings("java:S6548")
34	public class ThreadPoolMetrics implements IMetricSet {
35	private AbstractMetricService metricService;
36	private Map<String, IThreadPoolMBean> notRegisteredPoolMap = new HashMap<>();	1✔
37	private Map<String, IThreadPoolMBean> registeredPoolMap = new HashMap<>();	1✔
38
39	public static ThreadPoolMetrics getInstance() {
40	return ThreadPoolMetricsHolder.INSTANCE;	1✔
41	}
42
43	private ThreadPoolMetrics() {}	1✔
44
45	public void registerThreadPool(IThreadPoolMBean pool, String name) {
46	synchronized (this) {	1✔
47	if (metricService == null) {	1✔
48	notRegisteredPoolMap.put(name, pool);	1✔
49	} else {
50	registeredPoolMap.put(name, pool);	×
51	metricService.createAutoGauge(	×
52	SystemMetric.THREAD_POOL_ACTIVE_THREAD_COUNT.toString(),	×
53	MetricLevel.IMPORTANT,
54	registeredPoolMap,
55	map -> registeredPoolMap.get(name).getActiveCount(),	×
56	SystemTag.POOL_NAME.toString(),	×
57	name);
58	metricService.createAutoGauge(	×
59	SystemMetric.THREAD_POOL_CORE_SIZE.toString(),	×
60	MetricLevel.IMPORTANT,
61	registeredPoolMap,
62	map -> registeredPoolMap.get(name).getCorePoolSize(),	×
63	SystemTag.POOL_NAME.toString(),	×
64	name);
65	metricService.createAutoGauge(	×
66	SystemMetric.THREAD_POOL_WAITING_TASK_COUNT.toString(),	×
67	MetricLevel.IMPORTANT,
68	registeredPoolMap,
69	map -> registeredPoolMap.get(name).getQueueLength(),	×
70	SystemTag.POOL_NAME.toString(),	×
71	name);
72	metricService.createAutoGauge(	×
73	SystemMetric.THREAD_POOL_DONE_TASK_COUNT.toString(),	×
74	MetricLevel.IMPORTANT,
75	registeredPoolMap,
76	map -> registeredPoolMap.get(name).getCompletedTaskCount(),	×
77	SystemTag.POOL_NAME.toString(),	×
78	name);
79	metricService.createAutoGauge(	×
80	SystemMetric.THREAD_POOL_LARGEST_POOL_SIZE.toString(),	×
81	MetricLevel.IMPORTANT,
82	registeredPoolMap,
83	map -> registeredPoolMap.get(name).getLargestPoolSize(),	×
84	SystemTag.POOL_NAME.toString(),	×
85	name);
86	}
87	}	1✔
88	}	1✔
89
90	@Override
91	public void bindTo(AbstractMetricService metricService) {
92	synchronized (this) {	×
93	this.metricService = metricService;	×
94	for (Map.Entry<String, IThreadPoolMBean> entry : notRegisteredPoolMap.entrySet()) {	×
95	metricService.createAutoGauge(	×
96	SystemMetric.THREAD_POOL_ACTIVE_THREAD_COUNT.toString(),	×
97	MetricLevel.IMPORTANT,
98	registeredPoolMap,
99	map -> entry.getValue().getActiveCount(),	×
100	SystemTag.POOL_NAME.toString(),	×
101	entry.getKey());	×
102	metricService.createAutoGauge(	×
103	SystemMetric.THREAD_POOL_CORE_SIZE.toString(),	×
104	MetricLevel.IMPORTANT,
105	registeredPoolMap,
106	map -> entry.getValue().getCorePoolSize(),	×
107	SystemTag.POOL_NAME.toString(),	×
108	entry.getKey());	×
109	metricService.createAutoGauge(	×
110	SystemMetric.THREAD_POOL_WAITING_TASK_COUNT.toString(),	×
111	MetricLevel.IMPORTANT,
112	registeredPoolMap,
113	map -> entry.getValue().getQueue().size(),	×
114	SystemTag.POOL_NAME.toString(),	×
115	entry.getKey());	×
116	metricService.createAutoGauge(	×
117	SystemMetric.THREAD_POOL_DONE_TASK_COUNT.toString(),	×
118	MetricLevel.IMPORTANT,
119	registeredPoolMap,
120	map -> entry.getValue().getCompletedTaskCount(),	×
121	SystemTag.POOL_NAME.toString(),	×
122	entry.getKey());	×
123	metricService.createAutoGauge(	×
124	SystemMetric.THREAD_POOL_LARGEST_POOL_SIZE.toString(),	×
125	MetricLevel.IMPORTANT,
126	registeredPoolMap,
127	map -> entry.getValue().getLargestPoolSize(),	×
128	SystemTag.POOL_NAME.toString(),	×
129	entry.getKey());	×
130	}	×
131	registeredPoolMap.putAll(notRegisteredPoolMap);	×
132	notRegisteredPoolMap.clear();	×
133	}	×
134	}	×
135
136	@Override
137	public void unbindFrom(AbstractMetricService metricService) {
138	for (Map.Entry<String, IThreadPoolMBean> entry : registeredPoolMap.entrySet()) {	×
139	metricService.remove(	×
140	MetricType.GAUGE,
141	SystemMetric.THREAD_POOL_ACTIVE_THREAD_COUNT.toString(),	×
142	SystemTag.POOL_NAME.toString(),	×
143	entry.getKey());	×
144	metricService.remove(	×
145	MetricType.GAUGE,
146	SystemMetric.THREAD_POOL_CORE_SIZE.toString(),	×
147	SystemTag.POOL_NAME.toString(),	×
148	entry.getKey());	×
149	metricService.remove(	×
150	MetricType.GAUGE,
151	SystemMetric.THREAD_POOL_WAITING_TASK_COUNT.toString(),	×
152	SystemTag.POOL_NAME.toString(),	×
153	entry.getKey());	×
154	metricService.remove(	×
155	MetricType.GAUGE,
156	SystemMetric.THREAD_POOL_DONE_TASK_COUNT.toString(),	×
157	SystemTag.POOL_NAME.toString(),	×
158	entry.getKey());	×
159	metricService.remove(	×
160	MetricType.GAUGE,
161	SystemMetric.THREAD_POOL_LARGEST_POOL_SIZE.toString(),	×
162	SystemTag.POOL_NAME.toString(),	×
163	entry.getKey());	×
164	}	×
165	}	×
166
167	private static class ThreadPoolMetricsHolder {
168	private static final ThreadPoolMetrics INSTANCE = new ThreadPoolMetrics();	1✔
169
170	private ThreadPoolMetricsHolder() {}
171	}
172	}

apache / iotdb / #9678

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous