private void updatePartitionLagAndLeadSensors(Set<TopicPartition> assignedPartitions) { if (this.assignedPartitions != null) { for (TopicPartition tp : this.assignedPartitions) { if (!assignedPartitions.contains(tp)) { metrics.removeSensor(partitionLagMetricName(tp)); metrics.removeSensor(partitionLeadMetricName(tp)); } } } this.assignedPartitions = assignedPartitions; }
public void run() { for (Map.Entry<String, Sensor> sensorEntry : sensors.entrySet()) { // removeSensor also locks the sensor object. This is fine because synchronized is reentrant // There is however a minor race condition here. Assume we have a parent sensor P and child sensor C. // Calling record on C would cause a record on P as well. // So expiration time for P == expiration time for C. If the record on P happens via C just after P is removed, // that will cause C to also get removed. // Since the expiration time is typically high it is not expected to be a significant concern // and thus not necessary to optimize synchronized (sensorEntry.getValue()) { if (sensorEntry.getValue().hasExpired()) { log.debug("Removing expired sensor {}", sensorEntry.getKey()); removeSensor(sensorEntry.getKey()); } } } } }
public void close() { for (MetricName metricName : topLevelMetricNames) metrics.removeMetric(metricName); for (Sensor sensor : sensors) metrics.removeSensor(sensor.name()); } }
/** * Remove a sensor (if it exists), associated metrics and its children. * * @param name The name of the sensor to be removed */ public void removeSensor(String name) { Sensor sensor = sensors.get(name); if (sensor != null) { List<Sensor> childSensors = null; synchronized (sensor) { synchronized (this) { if (sensors.remove(name, sensor)) { for (KafkaMetric metric : sensor.metrics()) removeMetric(metric.metricName()); log.debug("Removed sensor with name {}", name); childSensors = childrenSensors.remove(sensor); for (final Sensor parent : sensor.parents()) { childrenSensors.getOrDefault(parent, emptyList()).remove(sensor); } } } } if (childSensors != null) { for (Sensor childSensor : childSensors) removeSensor(childSensor.name()); } } }
public void close(final Metrics metrics) { metrics.removeSensor(sensor.name()); metrics.removeMetric(metric.metricName()); }
@Test public void testRemoveChildSensor() { final Metrics metrics = new Metrics(); final Sensor parent = metrics.sensor("parent"); final Sensor child = metrics.sensor("child", parent); assertEquals(singletonList(child), metrics.childrenSensors().get(parent)); metrics.removeSensor("child"); assertEquals(emptyList(), metrics.childrenSensors().get(parent)); }
/** * Verifies that concurrent sensor add, remove, updates and read don't result * in errors or deadlock. */ @Test public void testConcurrentReadUpdate() throws Exception { final Random random = new Random(); final Deque<Sensor> sensors = new ConcurrentLinkedDeque<>(); metrics = new Metrics(new MockTime(10)); SensorCreator sensorCreator = new SensorCreator(metrics); final AtomicBoolean alive = new AtomicBoolean(true); executorService = Executors.newSingleThreadExecutor(); executorService.submit(new ConcurrentMetricOperation(alive, "record", () -> sensors.forEach(sensor -> sensor.record(random.nextInt(10000))))); for (int i = 0; i < 10000; i++) { if (sensors.size() > 5) { Sensor sensor = random.nextBoolean() ? sensors.removeFirst() : sensors.removeLast(); metrics.removeSensor(sensor.name()); } StatType statType = StatType.forId(random.nextInt(StatType.values().length)); sensors.add(sensorCreator.createSensor(statType, i)); for (Sensor sensor : sensors) { for (KafkaMetric metric : sensor.metrics()) { assertNotNull("Invalid metric value", metric.metricValue()); } } } alive.set(false); }
if (sensors.size() > 10) { Sensor sensor = random.nextBoolean() ? sensors.removeFirst() : sensors.removeLast(); metrics.removeSensor(sensor.name());
metrics.removeSensor("test.parent1"); assertNull(metrics.getSensor("test.parent1")); assertNull(metrics.metrics().get(metrics.metricName("test.parent1.count", "grp1"))); metrics.removeSensor("test.gchild2"); assertNull(metrics.getSensor("test.gchild2")); assertNull(metrics.childrenSensors().get(sensor)); metrics.removeSensor("test.child2"); assertNull(metrics.getSensor("test.child2")); assertNull(metrics.childrenSensors().get(sensor)); metrics.removeSensor("test.parent2"); assertNull(metrics.getSensor("test.parent2")); assertNull(metrics.childrenSensors().get(sensor));
public final void removeAllThreadLevelSensors() { synchronized (threadLevelSensors) { while (!threadLevelSensors.isEmpty()) { metrics.removeSensor(threadLevelSensors.pop()); } } }
public final void removeAllNodeLevelSensors(final String taskName, final String processorNodeName) { final String key = nodeSensorPrefix(taskName, processorNodeName); synchronized (nodeLevelSensors) { if (nodeLevelSensors.containsKey(key)) { while (!nodeLevelSensors.get(key).isEmpty()) { metrics.removeSensor(nodeLevelSensors.get(key).pop()); } } } }
/** * Deletes a sensor and its parents, if any */ @Override public void removeSensor(final Sensor sensor) { Objects.requireNonNull(sensor, "Sensor is null"); metrics.removeSensor(sensor.name()); final Sensor parent = parentSensors.get(sensor); if (parent != null) { metrics.removeSensor(parent.name()); } }
public final void removeAllCacheLevelSensors(final String taskName, final String cacheName) { final String key = cacheSensorPrefix(taskName, cacheName); synchronized (cacheLevelSensors) { if (cacheLevelSensors.containsKey(key)) { while (!cacheLevelSensors.get(key).isEmpty()) { metrics.removeSensor(cacheLevelSensors.get(key).pop()); } cacheLevelSensors.remove(key); } } }
public final void removeAllTaskLevelSensors(final String taskName) { final String key = taskSensorPrefix(taskName); synchronized (taskLevelSensors) { if (taskLevelSensors.containsKey(key)) { while (!taskLevelSensors.get(key).isEmpty()) { metrics.removeSensor(taskLevelSensors.get(key).pop()); } taskLevelSensors.remove(key); } } }
public final void removeAllStoreLevelSensors(final String taskName, final String storeName) { final String key = storeSensorPrefix(taskName, storeName); synchronized (storeLevelSensors) { if (storeLevelSensors.containsKey(key)) { while (!storeLevelSensors.get(key).isEmpty()) { metrics.removeSensor(storeLevelSensors.get(key).pop()); } storeLevelSensors.remove(key); } } }
/** * Remove all sensors and metrics associated with this group. */ public synchronized void close() { for (String sensorName : sensorNames) { metrics.removeSensor(sensorName); } sensorNames.clear(); for (MetricName metricName : new HashSet<>(metrics.metrics().keySet())) { if (groupId.includes(metricName)) { metrics.removeMetric(metricName); } } } }