org.jgroups.protocols.MsgStats Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of wildfly-client-all
This artifact provides a single jar that contains all classes required to use remote Jakarta Enterprise Beans and Jakarta Messaging, including all dependencies. It is intended for use by those not using maven, maven users should just import the Jakarta Enterprise Beans and Jakarta Messaging BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up with different versions on classes on the class path).
The newest version!
package org.jgroups.protocols;

import org.jgroups.Address;
import org.jgroups.Message;
import org.jgroups.annotations.ManagedAttribute;
import org.jgroups.annotations.Property;
import org.jgroups.util.AverageMinMax;
import org.jgroups.util.MessageBatch;
import org.jgroups.util.Util;

import java.lang.reflect.Field;
import java.util.concurrent.atomic.LongAdder;
import java.util.stream.Stream;

import static org.jgroups.conf.AttributeType.BYTES;
import static org.jgroups.conf.AttributeType.SCALAR;

/**
 * Class which has all the stats about received/sent messages etc. (in TP)
 * @author Bela Ban
 * @since  4.0
 */
public class MsgStats {
    @Property(description="Whether metrics should be logged")
    protected boolean             enabled=true;

    @ManagedAttribute(description="Number of unicast messages sent",type=SCALAR)
    protected final LongAdder     num_ucasts_sent=new LongAdder();
    @ManagedAttribute(description="Number of unicast messages received",type=SCALAR)
    protected final LongAdder     num_ucasts_received=new LongAdder();

    @ManagedAttribute(description="Number of multicast messages sent",type=SCALAR)
    protected final LongAdder     num_mcasts_sent=new LongAdder();
    @ManagedAttribute(description="Total number of multicast messages received",type=SCALAR)
    protected final LongAdder     num_mcasts_received=new LongAdder();

    @ManagedAttribute(description="Number of single messages sent (by the bundler)",type=SCALAR)
    protected final LongAdder     num_single_msgs_sent=new LongAdder();
    @ManagedAttribute(description="Number of single messages received (by the transport)",type=SCALAR)
    protected final LongAdder     num_single_msgs_received=new LongAdder();

    @ManagedAttribute(description="Number of batches sent (by the bundler)",type=SCALAR)
    protected final LongAdder     num_batches_sent=new LongAdder();
    @ManagedAttribute(description="Number of batches received (by the transport)",type=SCALAR)
    protected final LongAdder     num_batches_received=new LongAdder();

    /** The average number of messages in a received {@link MessageBatch} */
    @ManagedAttribute(description="Returns the average batch size of received batches")
    protected final AverageMinMax avg_batch_size=new AverageMinMax();

    @ManagedAttribute(description="Number of multicast bytes sent",type=BYTES)
    protected final LongAdder     num_mcast_bytes_sent=new LongAdder();
    @ManagedAttribute(description="Number of multicast bytes received",type=BYTES)
    protected final LongAdder     num_mcast_bytes_received=new LongAdder();

    @ManagedAttribute(description="Number of unicast bytes sent",type=BYTES)
    protected final LongAdder     num_ucast_bytes_sent=new LongAdder();
    @ManagedAttribute(description="Number of unicast bytes received",type=BYTES)
    protected final LongAdder     num_ucast_bytes_received=new LongAdder();

    public boolean  enabled()                   {return enabled;}
    public MsgStats enable(boolean b)           {enabled=b; return this;}

    @ManagedAttribute(description="Number of messages sent (mcasts and ucasts sent)",type=SCALAR)
    public long     getNumMsgsSent()            {return num_mcasts_sent.sum() + num_ucasts_sent.sum();}

    @ManagedAttribute(description="Number of messages received (mcasts and ucasts received)",type=SCALAR)
    public long     getNumMsgsReceived()        {return num_mcasts_received.sum() + num_ucasts_received.sum();}

    public AverageMinMax getAvgBatchSize()      {return avg_batch_size;}

    @ManagedAttribute(description="Total number of bytes sent (unicast + multicast bytes)",type=BYTES)
    public long     getNumBytesSent()           {return num_mcast_bytes_sent.sum() + num_ucast_bytes_sent.sum();}

    @ManagedAttribute(description="Total number of bytes received (unicast + multicast)",type=BYTES)
    public long     getNumBytesReceived()       {return num_mcast_bytes_received.sum() + num_ucast_bytes_received.sum();}

    public long     getNumUcastsSent()          {return num_ucasts_sent.sum();}

    public long     getNumMcastsSent()          {return num_mcasts_sent.sum();}

    public long     getNumUcastsReceived()      {return num_ucasts_received.sum();}

    public long     getNumMcastsReceived()      {return num_mcasts_received.sum();}

    public long     getNumSingleMsgsSent()      {return num_single_msgs_sent.sum();}
    public MsgStats incrNumSingleMsgsSent()     {if(enabled) num_single_msgs_sent.increment(); return this;}

    public long     getNumBatchesSent()         {return num_batches_sent.sum();}
    public MsgStats incrNumBatchesSent()        {if(enabled) num_batches_sent.increment(); return this;}
    public MsgStats incrNumBatchesSent(int n)   {if(enabled) num_batches_sent.add(n); return this;}

    public long     getNumBatchesReceived()     {return num_batches_received.sum();}

    public long     getNumUcastBytesSent()      {return num_ucast_bytes_sent.sum();}

    public long     getNumMcastBytesSent()      {return num_mcast_bytes_sent.sum();}

    public long     getNumUcastBytesReceived()  {return num_ucast_bytes_received.sum();}

    public long     getNumMcastBytesReceived()  {return num_mcast_bytes_received.sum();}


    public MsgStats sent(Address dest, int length) {
        if(!enabled)
            return this;
        if(dest == null) // multicast
            return add(num_mcasts_sent, 1, num_mcast_bytes_sent, length);
        return add(num_ucasts_sent, 1, num_ucast_bytes_sent, length);
    }

    public MsgStats sent(Message msg) {
        return (msg == null || !enabled)? this : sent(msg.dest(), msg.getLength());
    }

    public MsgStats received(Address dest, int length) {
        if(!enabled)
            return this;
        if(dest == null)
            return add(num_mcasts_received, 1, num_mcast_bytes_received, length);
        return add(num_ucasts_received, 1, num_ucast_bytes_received, length);
    }

    public MsgStats received(Message msg) {
        if(msg == null || !enabled)
            return this;
        num_single_msgs_received.increment();
        return received(msg.dest(), msg.getLength());
    }

    public MsgStats received(MessageBatch batch) {
        if(batch == null || !enabled)
            return this;
        num_batches_received.increment();
        int num_msgs=batch.size();
        int length=batch.length();
        avg_batch_size.add(num_msgs);
        if(batch.dest() == null)
            return add(num_mcasts_received, num_msgs, num_mcast_bytes_received, length);
        return add(num_ucasts_received, num_msgs, num_ucast_bytes_received, length);
    }


    public MsgStats reset() {
        Stream.of(num_ucasts_sent, num_ucasts_received,
                  num_mcasts_sent, num_mcasts_received,
                  num_single_msgs_sent, num_single_msgs_received,
                  num_batches_sent, num_batches_received,
                  num_mcast_bytes_sent, num_mcast_bytes_received,
                  num_ucast_bytes_sent, num_ucast_bytes_received)
          .forEach(LongAdder::reset);
        avg_batch_size.clear();
        return this;
    }

    @Override
    public String toString() {
        return toString(false);
    }

    public String toString(boolean details) {
        StringBuilder sb=new StringBuilder();
        if(!details) {
            sb.append(String.format("%,d sent (%s) %,d received (%s)", getNumMsgsSent(), Util.printBytes(getNumBytesSent()),
                                    getNumMsgsReceived(), Util.printBytes(getNumBytesReceived())));
            return sb.toString();
        }
        Field[] fields=MsgStats.class.getDeclaredFields();
        for(Field field: fields) {
            try {
                Object val=Util.getField(field, this);
                sb.append(field.getName()).append(": ").append(val).append("\n");
            }
            catch(Throwable t) {

            }
        }
        return sb.toString();
    }

    protected MsgStats add(LongAdder msgs, int num_msgs, LongAdder bytes, int length) {
        msgs.add(num_msgs);
        if(length > 0)
            bytes.add(length);
        return this;
    }
}