Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package io.advantageous.qbit.metrics.support;
  
  import org.slf4j.Logger;
  
created by rhightower on 5/22/15.
 
 public class StatsDReplicator implements StatReplicatorQueueCallBackHandler {
 
     private final int flushRateIntervalMS;
     private final ByteBuffer sendBuffer;
     private final boolean multiMetrics;
 
     private final Random random = new Random();
     private final Logger logger = LoggerFactory.getLogger(StatsDReplicator.class);
     private final InetSocketAddress address;
     private final DatagramChannel channel;
 
     private long lastFlush;
     private long time;
 
     /*
     Sets
 
 StatsD supports counting unique occurences of events between flushes, using a Set to store all occurring events.
 
 uniques:765|s
 If the count at flush is 0 then you can opt to send no metric at all for this set, by setting config.deleteSets.
      */
 
     public StatsDReplicator(String hostint portboolean multiMetricsint bufferSizeint flushRateIntervalMSthrows IOException {
         this(InetAddress.getByName(host), portmultiMetricsbufferSizeflushRateIntervalMS);
     }
 
     public StatsDReplicator(InetAddress hostint portboolean multiMetricsint bufferSizeint flushRateIntervalMSthrows IOException {
          = new InetSocketAddress(hostport);
          = DatagramChannel.open();
         this. = multiMetrics;
         this. = flushRateIntervalMS;
          = ByteBuffer.allocate(bufferSize);
 
     }
 
     protected void finalize() throws Throwable {
         super.finalize();
         flushStatSend();
     }
 
 
     @SuppressWarnings("UnusedReturnValue")
     public boolean timing(String keyint value) {
         return timing(keyvalue, 1.0);
     }
 
     public boolean timing(String keyint valuedouble sampleRate) {
         return send(sampleRate, String.format(."%s:%d|ms"keyvalue));
     }
 
     public boolean decrement(String key) {
         return increment(key, -1, 1.0);
     }
 
     public boolean decrement(String keyint magnitude) {
         return decrement(keymagnitude, 1.0);
     }
 
     public boolean decrement(String keyint magnitudedouble sampleRate) {
         magnitude = magnitude < 0 ? magnitude : -magnitude;
         return increment(keymagnitudesampleRate);
     }
 
     public boolean decrement(String... keys) {
         return increment(-1, 1.0, keys);
     }
 
     public boolean decrement(int magnitudeString... keys) {
         magnitude = magnitude < 0 ? magnitude : -magnitude;
         return increment(magnitude, 1.0, keys);
     }
 
     public boolean decrement(int magnitudedouble sampleRateString... keys) {
         magnitude = magnitude < 0 ? magnitude : -magnitude;
         return increment(magnitudesampleRatekeys);
     }
 
     public boolean increment(String key) {
         return increment(key, 1, 1.0);
    }
    @SuppressWarnings("UnusedReturnValue")
    public boolean increment(String keyint magnitude) {
        return increment(keymagnitude, 1.0);
    }
    public boolean increment(String keyint magnitudedouble sampleRate) {
        String stat = String.format(."%s:%s|c"keymagnitude);
        return send(sampleRatestat);
    }
    public boolean increment(int magnitudedouble sampleRateString... keys) {
        String[] stats = new String[keys.length];
        for (int i = 0; i < keys.lengthi++) {
            stats[i] = String.format(."%s:%s|c"keys[i], magnitude);
        }
        return send(sampleRatestats);
    }
    @SuppressWarnings("UnusedReturnValue")
    public boolean gauge(String keydouble magnitude) {
        return gauge(keymagnitude, 1.0);
    }
    public boolean gauge(String keydouble magnitudedouble sampleRate) {
        final String stat = String.format(."%s:%s|g"keymagnitude);
        return send(sampleRatestat);
    }
    private boolean send(double sampleRateString... stats) {
        boolean sentSomething = false// didn't send anything
        if (sampleRate < 1.0) {
            for (String stat : stats) {
                if (.nextDouble() <= sampleRate) {
                    stat = String.format(."%s|@%f"statsampleRate);
                    if (doSend(stat)) {
                        sentSomething = true;
                    }
                }
            }
        } else {
            for (String stat : stats) {
                if (doSend(stat)) {
                    sentSomething = true;
                }
            }
        }
        return sentSomething;
    }
    private boolean doSend(String stat) {
        try {
            final byte[] data = stat.getBytes("utf-8");
            // If we're going to go past the threshold of the buffer then flush.
            // the +1 is for the potential '\n' in multi_metrics below
            if (.remaining() < (data.length + 1)) {
                flushStatSend();
            }
            if (.position() > 0) {         // multiple metrics are separated by '\n'
                .put((byte'\n');
            }
            .put(data);   // append the data
            if (!) {
                flushStatSend();
            }
            return true;
        } catch (IOException e) {
            .error(
                    String.format("Could not send stat %s to host %s:%d",
                            .toString(), .getHostName(),
                            .getPort()), e);
            return false;
        }
    }
    @SuppressWarnings("UnusedReturnValue")
    public boolean flushStatSend() {
        try {
            final int sizeOfBuffer = .position();
            if (sizeOfBuffer <= 0) {
                return false;
            }
            final int sentByteCount = sendBufferOverChannel();
            if (sizeOfBuffer == sentByteCount) {
                return true;
            } else {
                .error(String.format(
                        "Could not send all of stat %s to host %s:%d. Only sent %d bytes out of %d bytes".toString(),
                        .getHostName(), .getPort(), sentByteCountsizeOfBuffer));
                return false;
            }
        } catch (IOException e) {
            .error(
                    String.format("Could not send stat %s to host %s:%d".toString(), .getHostName(),
                            .getPort()), e);
            return false;
        }
    }
    private int sendBufferOverChannel() throws IOException {
        .flip();
        final int sentByteCount = .send();
        .rewind();
        return sentByteCount;
    }
    @Override
    public void replicateCount(final String namefinal int countfinal long time) {
        increment(namecount);
    }
    @Override
    public void replicateLevel(final String namefinal int levelfinal long time) {
        gauge(namelevel);
    }
    @Override
    public void replicateTiming(String nameint timedlong time) {
        timing(nametimed);
    }
    private void flushIfNeeded() {
        long delta =  - ;
        if (delta > ) {
            flushStatSend();
             = ;
        }
    }
    @Override
    public void queueLimit() {
         = Timer.timer().now();
        flushIfNeeded();
    }
    @Override
    public void queueEmpty() {
         = Timer.timer().now();
        flushIfNeeded();
    }
New to GrepCode? Check out our FAQ X