Service.java

package net.sf.appstatus.services;

import java.util.concurrent.atomic.AtomicLong;

import net.sf.appstatus.core.services.IService;

import org.apache.commons.lang3.ObjectUtils;

public class Service implements IService {
	protected AtomicLong cacheHits = new AtomicLong();
	protected AtomicLong hits = new AtomicLong();
	protected AtomicLong running = new AtomicLong();
	protected String name;
	protected String group;
	private CachedCallStatistics totalStats;
	private CachedCallStatistics windowStats;
	private CachedCallStatistics windowPrevisiousStats;
	private long windowSize = 2000;
	private long windowStart = 0;
	private int minMaxDelay;

	public Service(int minMaxDelay) {
		this.minMaxDelay = minMaxDelay;
		totalStats = new CachedCallStatistics(minMaxDelay);
		windowStats = new CachedCallStatistics(minMaxDelay);
		windowPrevisiousStats = new CachedCallStatistics(minMaxDelay);
	}

	public long getRunning() {

		while (true) {
			long runningCalls = running.get();

			if (runningCalls < 0) {
				// Try to fix value
				running.compareAndSet(runningCalls, 0);
			} else
				return runningCalls;
		}

	}


	/**
	 * This method is synchronized to ensure correct statistics computation
	 * 
	 * @param executionTime
	 * @param cacheHit
	 * @param failure
	 * @param error
	 */
	public void addCall(Long executionTime, boolean cacheHit, boolean failure, boolean error, int nestedCalls) {
		totalStats.addCall(executionTime, cacheHit, failure, error, nestedCalls);

		updateWindows();
		windowStats.addCall(executionTime, cacheHit, failure, error, nestedCalls);
	}

	/**
	 * Archive previous window if expired, and create a new window for next
	 * results.
	 */
	private void updateWindows() {
		long currentTime = System.currentTimeMillis();
		if (currentTime - windowStart > windowSize) {
			synchronized (this) {
				if (currentTime - windowStart > windowSize) {

					if (currentTime - windowStart <= 2 * windowSize) {
						windowPrevisiousStats = windowStats;
					} else {
						windowPrevisiousStats = new CachedCallStatistics(minMaxDelay);
					}
					windowStats = new CachedCallStatistics(minMaxDelay);
					windowStart = currentTime;
				}

			}
		}
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getGroup() {
		return group;
	}

	public void setGroup(String group) {
		this.group = group;
	}

	public Double getAvgResponseTime() {
		return totalStats.getDirectStatistics().getAvgResponseTime();
	}

	public long getCacheHits() {
		return cacheHits.get();
	}

	public long getHits() {
		return hits.get();
	}

	public long getFailures() {
		return totalStats.getFailures();
	}

	public long getErrors() {
		return totalStats.getErrors();
	}

	public Long getMaxResponseTime() {
		return totalStats.getDirectStatistics().getMaxResponseTime();
	}

	public Long getMinResponseTime() {
		return totalStats.getDirectStatistics().getMinResponseTime();
	}

	public Double getAvgResponseTimeWithCache() {
		return totalStats.getCacheStatistics().getAvgResponseTime();
	}

	public Long getMaxResponseTimeWithCache() {
		return totalStats.getCacheStatistics().getMaxResponseTime();
	}

	public Long getMinResponseTimeWithCache() {
		return totalStats.getCacheStatistics().getMinResponseTime();
	}

	public double getAvgNestedCalls() {
		return totalStats.getDirectStatistics().getAvgNestedCalls();
	}

	public double getAvgNestedCallsWithCache() {
		return totalStats.getCacheStatistics().getAvgNestedCalls();
	}

	public int compareTo(IService otherService) {
		int groupCompare = ObjectUtils.compare(group, otherService.getGroup());
		if (groupCompare != 0) {
			return groupCompare;
		}

		return ObjectUtils.compare(name, otherService.getName());
	}

	public double getCurrentRate() {
		updateWindows();
		return (windowPrevisiousStats.getTotalHits() * 1000) / (double) windowSize;
	}

}