patterntesting.runtime.monitor.SimpleProfileMonitorFactory Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of patterntesting-rt Show documentation

PatternTesting Runtime (patterntesting-rt) is the runtime component for the PatternTesting framework. It provides the annotations and base classes for the PatternTesting testing framework (e.g. patterntesting-check, patterntesting-concurrent or patterntesting-exception) but can be also used standalone for classpath monitoring or profiling. It uses AOP and AspectJ to perform this feat.

There is a newer version: 2.5.0

Show newest version

/*
 * Copyright (c) 2015 by Oli B.
 *
 * Licensed 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 orimplied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * (c)reated 19.12.2015 by Oli B. ([email protected])
 */

package patterntesting.runtime.monitor;

import java.util.List;

import org.apache.logging.log4j.*;

/**
 * This is the counterpart to JamonMonitorFactory. It encapsulate the different
 * behaviour of the {@link SimpleProfileMonitor} for the ProfileStatistic class.
 *
 * @author oboehm ([email protected])
 * @since 1.6 (19.12.2015)
 */
public final class SimpleProfileMonitorFactory extends ProfileMonitorFactory {

	private static final Logger LOG = LogManager.getLogger(SimpleProfileMonitorFactory.class);
	private int maxSize = Integer.MAX_VALUE;

	/**
	 * Instantiates a new jamon monitor factory.
	 *
	 * @param rootMonitor
	 *            the root monitor
	 */
	public SimpleProfileMonitorFactory(final SimpleProfileMonitor rootMonitor) {
		super(rootMonitor);
	}

	/**
	 * Gets the monitors.
	 *
	 * @return the monitors
	 */
	@Override
	public ProfileMonitor[] getMonitors() {
		return this.rootMonitor.getMonitors();
	}

	/**
	 * Gets the monitor.
	 *
	 * @param label
	 *            the label
	 * @return the monitor
	 * @see ProfileMonitorFactory#getMonitor(String)
	 */
	@Override
	public ProfileMonitor getMonitor(final String label) {
		SimpleProfileMonitor parent = this.getSimpleProfileMonitor(label);
		return new SimpleProfileMonitor(label, parent);
	}

	private SimpleProfileMonitor getSimpleProfileMonitor(final String sig) {
		SimpleProfileMonitor monitor = this.rootMonitor.getMonitor(sig);
		if (monitor == null) {
			monitor = new SimpleProfileMonitor(sig, this.rootMonitor);
			int tooMuch = this.rootMonitor.getNumberOfMonitors() - maxSize;
			for (int i = 0; i < tooMuch; i++) {
				ProfileMonitor[] monitors = this.rootMonitor.getMonitors();
				SimpleProfileMonitor oldest = getOldestMonitorOf(monitors);
				this.removeMonitor(oldest);
			}
		}
		return monitor;
	}

	private void removeMonitor(final SimpleProfileMonitor monitor) {
		this.rootMonitor.removeMonitor(monitor);
	}

	private static SimpleProfileMonitor getOldestMonitorOf(final ProfileMonitor[] monitors) {
		ProfileMonitor oldest = monitors[0];
		int maxHits = oldest.getHits();
		double maxAvg = oldest.getAvg();
		double maxTotal = oldest.getTotal();
		double maxMax = oldest.getMax();
		for (int i = 1; i < monitors.length; i++) {
			ProfileMonitor mon = monitors[i];
			if (mon == null) {
				LOG.info("Will return {} as oldest because monitor {} is null (lost?).", oldest, i);
				break;
			}
			if (oldest.getLastAccess().after(mon.getFirstAccess()) && mon.getHits() <= maxHits && mon.getAvg() <= maxAvg
					&& mon.getTotal() <= maxTotal && mon.getMax() <= maxMax) {
				oldest = mon;
			} else {
				if (mon.getHits() > maxHits) {
					maxHits = mon.getHits();
				}
				if (mon.getAvg() > maxAvg) {
					maxAvg = mon.getAvg();
				}
				if (mon.getTotal() > maxTotal) {
					maxTotal = mon.getTotal();
				}
				if (mon.getMax() > maxMax) {
					maxMax = mon.getMax();
				}
			}
		}
		return (SimpleProfileMonitor) oldest;
	}

	/**
	 * Gets the max num monitors.
	 *
	 * @return the max num monitors
	 * @see ProfileMonitorFactory#getMaxNumMonitors()
	 */
	@Override
	public int getMaxNumMonitors() {
		return this.maxSize;
	}

	/**
	 * Here you can set the maximal number of monitors.
	 *
	 * @param size
	 *            the new max size
	 * @since 1.6
	 */
	@Override
	public void setMaxNumMonitors(final int size) {
		maxSize = size;
		ProfileMonitor[] monitors = this.rootMonitor.getMonitors();
		int tooMuch = monitors.length - size;
		for (int i = 0; i < tooMuch; i++) {
			SimpleProfileMonitor oldest = getOldestMonitorOf(monitors);
			this.removeMonitor(oldest);
			monitors = this.rootMonitor.getMonitors();
		}
		LOG.debug("Max size is set to {}, actual size is {}.", size, monitors.length);
	}

	/**
	 * Reset.
	 *
	 * @see ProfileMonitorFactory#reset()
	 */
	@Override
	public void reset() {
		this.rootMonitor.reset();
	}

	/**
	 * Adds the monitors.
	 *
	 * @param labels
	 *            the labels
	 * @see ProfileMonitorFactory#addMonitors(java.util.List)
	 */
	@Override
	public void addMonitors(final List labels) {
		this.rootMonitor.addChildren(labels);
	}

}