JMeter example source code file (Stats.java)

This example JMeter source code file (Stats.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - JMeter tags/keywords

active, active_per, active_per, connector, connector, dead, dead, default_memory_factor, default_thread_factor, healthy, healthy_per, warning, warning_per, warning_per

The JMeter Stats.java source code

/*
 * 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.jmeter.monitor.util;

import org.apache.jmeter.monitor.model.Connector;
import org.apache.jmeter.monitor.model.Status;

/**
 *
 * Description:
 * <p>
 * Stats is responsible for calculating the load and health of a given server.
 * It uses tomcat's status servlet results. A schema was generated for the XML
 * output and JAXB was used to generate classes.
 * <p>
 * The equations are:
 * <p>
 * memory weight = (int)(50 * (free/max))<br>
 * thread weight = (int)(50 * (current/max))
 * <p>
 * The load factors are stored in the properties files. Simply change the values
 * in the properties to change how load is calculated. The defaults values are
 * memory (50) and threads (50). The sum of the factors must equal 100.
 */
public class Stats {

    public static final int DEAD = 0;

    public static final int ACTIVE = 2;

    public static final int WARNING = 1;

    public static final int HEALTHY = 3;

    public static final int DEFAULT_MEMORY_FACTOR = 50;

    public static final int DEFAULT_THREAD_FACTOR = 50;

    public static final double HEALTHY_PER = 0.00;

    public static final double ACTIVE_PER = 0.25;

    public static final double WARNING_PER = 0.67;

    /**
     * The method is responsible for taking a status object and calculating an
     * int value from 1 to 100. We use a combination of free memory and free
     * threads. The current factor is 50/50.
     * <p>
     *
     * @param stat
     * @return calculated load value
     */
    public static int calculateLoad(Status stat) {
        if (stat != null) {
            // equation for calculating the weight
            // w = (int)(33 * (used/max))
            long totMem = stat.getJvm().getMemory().getTotal();
            long freeMem = stat.getJvm().getMemory().getFree();
            long usedMem = totMem - freeMem;
            double memdiv = (double) usedMem / (double) totMem;
            double memWeight = DEFAULT_MEMORY_FACTOR * memdiv;

            // changed the logic for BEA Weblogic in the case a
            // user uses Tomcat's status servlet without any
            // modifications. Weblogic will return nothing for
            // the connector, therefore we need to check the size
            // of the list. Peter 12.22.04
            double threadWeight = 0;
            if (stat.getConnector().size() > 0) {
                Connector cntr = fetchConnector(stat);
                int maxThread = cntr.getThreadInfo().getMaxThreads();
                int curThread = cntr.getThreadInfo().getCurrentThreadsBusy();
                double thdiv = (double) curThread / (double) maxThread;
                threadWeight = DEFAULT_THREAD_FACTOR * thdiv;
            }
            return (int) (memWeight + threadWeight);
        } else {
            return 0;
        }
    }

    /**
     * Method should calculate if the server is: dead, active, warning or
     * healthy. We do this by looking at the current busy threads.
     * <ol>
     * <li> free > spare is healthy
     * <li> free < spare is active
     * <li> busy threads > 75% is warning
     * <li> none of the above is dead
     * </ol>
     *
     * @param stat
     * @return integer representing the status
     */
    public static int calculateStatus(Status stat) {
        if (stat != null && stat.getConnector().size() > 0) {
            Connector cntr = fetchConnector(stat);
            int max = cntr.getThreadInfo().getMaxThreads();
            int current = cntr.getThreadInfo().getCurrentThreadsBusy();
            // int spare = cntr.getThreadInfo().getMaxSpareThreads();
            double per = (double) current / (double) max;
            if (per > WARNING_PER) {
                return WARNING;
            } else if (per >= ACTIVE_PER && per <= WARNING_PER) {
                return ACTIVE;
            } else if (per < ACTIVE_PER && per > HEALTHY_PER) {
                return HEALTHY;
            } else {
                return DEAD;
            }
        } else {
            return DEAD;
        }
    }

    /**
     * Method will calculate the memory load: used / max = load. The load value
     * is an integer between 1 and 100. It is the percent memory used. Changed
     * this to be more like other system monitors. Peter Lin 2-11-05
     *
     * @param stat
     * @return memory load
     */
    public static int calculateMemoryLoad(Status stat) {
        double load = 0;
        if (stat != null) {
            double total = stat.getJvm().getMemory().getTotal();
            double free = stat.getJvm().getMemory().getFree();
            double used = total - free;
            load = (used / total);
        }
        return (int) (load * 100);
    }

    /**
     * Method will calculate the thread load: busy / max = load. The value is an
     * integer between 1 and 100. It is the percent busy.
     *
     * @param stat
     * @return thread load
     */
    public static int calculateThreadLoad(Status stat) {
        int load = 0;
        if (stat != null && stat.getConnector().size() > 0) {
            Connector cntr = fetchConnector(stat);
            double max = cntr.getThreadInfo().getMaxThreads();
            double current = cntr.getThreadInfo().getCurrentThreadsBusy();
            load = (int) ((current / max) * 100);
        }
        return load;
    }

    /**
     * Method to get connector to use for calculate server status
     *
     * @param stat
     * @return connector
     */
    private static Connector fetchConnector(Status stat) {
        Connector cntr = null;
        String connectorPrefix = stat.getConnectorPrefix();
        if (connectorPrefix != null && connectorPrefix.length() > 0) {
           // loop to fetch desired connector
           for (int i = 0; i < stat.getConnector().size(); i++) {
               cntr = stat.getConnector().get(i);
               if (cntr.getName().startsWith(connectorPrefix)) {
                   return cntr;
               }
           }
        }
        // default : get first connector
        cntr = stat.getConnector().get(0);
        return cntr;
    }

}