res = new HashMap<>();
191 | BufferedReader br = new BufferedReader(new StringReader(cgroupContent));
192 |
193 | String line;
194 | while ((line = br.readLine()) != null) {
195 | String[] tokens = line.split(":");
196 | if (tokens.length != 3) {
197 | continue;
198 | }
199 | if (CGROUPV1_BASE_CONTROLLER.equals(tokens[1]) || CGROUPV2_BASE_CONTROLLER.equals(tokens[1])) {
200 | res.put(tokens[1], tokens[2]);
201 | }
202 | }
203 |
204 | br.close();
205 | return res;
206 | }
207 | }
208 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/ClientChannel.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.nio.channels.WritableByteChannel;
4 |
5 | interface ClientChannel extends WritableByteChannel {
6 | String getTransportType();
7 |
8 | int getMaxPacketSizeBytes();
9 | }
10 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/DatagramClientChannel.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.io.IOException;
4 | import java.net.SocketAddress;
5 | import java.nio.ByteBuffer;
6 | import java.nio.channels.DatagramChannel;
7 |
8 | class DatagramClientChannel implements ClientChannel {
9 | protected final DatagramChannel delegate;
10 | private final SocketAddress address;
11 |
12 | /**
13 | * Creates a new DatagramClientChannel using the default DatagramChannel.
14 | * @param address Address to connect the channel to
15 | * @throws IOException if an I/O error occurs
16 | */
17 | DatagramClientChannel(SocketAddress address) throws IOException {
18 | this(DatagramChannel.open(), address);
19 | }
20 |
21 | /**
22 | * Creates a new DatagramClientChannel that wraps the delegate.
23 | * @param delegate Implementation this instance wraps
24 | * @param address Address to connect the channel to
25 | */
26 | DatagramClientChannel(DatagramChannel delegate, SocketAddress address) {
27 | this.delegate = delegate;
28 | this.address = address;
29 | }
30 |
31 | @Override
32 | public boolean isOpen() {
33 | return delegate.isOpen();
34 | }
35 |
36 | @Override
37 | public int write(ByteBuffer src) throws IOException {
38 | return delegate.send(src, address);
39 | }
40 |
41 | @Override
42 | public void close() throws IOException {
43 | delegate.close();
44 | }
45 |
46 | @Override
47 | public String getTransportType() {
48 | return "udp";
49 | }
50 |
51 | @Override
52 | public String toString() {
53 | return "[" + getTransportType() + "] " + address;
54 | }
55 |
56 | @Override
57 | public int getMaxPacketSizeBytes() {
58 | return NonBlockingStatsDClient.DEFAULT_UDP_MAX_PACKET_SIZE_BYTES;
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/DirectStatsDClient.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | /**
4 | * DirectStatsDClient is an experimental extension of {@link StatsDClient} that allows for direct access to some
5 | * dogstatsd features.
6 | *
7 | * It is not recommended to use this client in production. This client might allow you to take advantage of
8 | * new features in the agent before they are released, but it might also break your application.
9 | */
10 | public interface DirectStatsDClient extends StatsDClient {
11 |
12 | /**
13 | * Records values for the specified named distribution.
14 | *
15 | *
The method doesn't take care of breaking down the values array if it is too large. It's up to the caller to
16 | * make sure the size is kept reasonable.
17 | *
18 | * This method is a DataDog extension, and may not work with other servers.
19 | *
20 | * This method is non-blocking and is guaranteed not to throw an exception.
21 | *
22 | * @param aspect the name of the distribution
23 | * @param values the values to be incorporated in the distribution
24 | * @param sampleRate percentage of time metric to be sent
25 | * @param tags array of tags to be added to the data
26 | */
27 | void recordDistributionValues(String aspect, double[] values, double sampleRate, String... tags);
28 |
29 |
30 | /**
31 | * Records values for the specified named distribution.
32 | *
33 | * The method doesn't take care of breaking down the values array if it is too large. It's up to the caller to
34 | * make sure the size is kept reasonable.
35 | *
36 | * This method is a DataDog extension, and may not work with other servers.
37 | *
38 | * This method is non-blocking and is guaranteed not to throw an exception.
39 | *
40 | * @param aspect the name of the distribution
41 | * @param values the values to be incorporated in the distribution
42 | * @param sampleRate percentage of time metric to be sent
43 | * @param tags array of tags to be added to the data
44 | */
45 | void recordDistributionValues(String aspect, long[] values, double sampleRate, String... tags);
46 | }
47 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/Event.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.util.Date;
4 |
5 | /**
6 | * An event to send.
7 | * @see http://docs.datadoghq.com/guides/dogstatsd/#events
8 | */
9 | public class Event {
10 | private String title;
11 | private String text;
12 | private long millisSinceEpoch = -1;
13 | private String hostname;
14 | private String aggregationKey;
15 | private String priority;
16 | private String sourceTypeName;
17 | private String alertType;
18 |
19 | public String getTitle() {
20 | return title;
21 | }
22 |
23 | public String getText() {
24 | return text;
25 | }
26 |
27 | /**
28 | * Get number of milliseconds since epoch started.
29 | * @return -1 if not set
30 | */
31 | public long getMillisSinceEpoch() {
32 | return millisSinceEpoch;
33 | }
34 |
35 | public String getHostname() {
36 | return hostname;
37 | }
38 |
39 | public String getAggregationKey() {
40 | return aggregationKey;
41 | }
42 |
43 | public String getPriority() {
44 | return priority;
45 | }
46 |
47 | public String getSourceTypeName() {
48 | return sourceTypeName;
49 | }
50 |
51 | public String getAlertType() {
52 | return alertType;
53 | }
54 |
55 | public static Builder builder() {
56 | return new Builder();
57 | }
58 |
59 | private Event(){}
60 |
61 | public enum Priority {
62 | LOW, NORMAL
63 | }
64 |
65 | public enum AlertType {
66 | ERROR, WARNING, INFO, SUCCESS
67 | }
68 |
69 | @SuppressWarnings({"AccessingNonPublicFieldOfAnotherObject",
70 | "PrivateMemberAccessBetweenOuterAndInnerClass", "ParameterHidesMemberVariable"})
71 | public static class Builder {
72 | private final Event event = new Event();
73 |
74 | private Builder() {}
75 |
76 | /**
77 | * Build factory method for the event.
78 | * @return Event built following specified options.
79 | */
80 | public Event build() {
81 | if ((event.title == null) || event.title.isEmpty()) {
82 | throw new IllegalStateException("event title must be set");
83 | }
84 | return event;
85 | }
86 |
87 | /**
88 | * Title for the event.
89 | * @param title
90 | * Event title ; mandatory
91 | * @return Builder object being used.
92 | */
93 | public Builder withTitle(final String title) {
94 | event.title = title;
95 | return this;
96 | }
97 |
98 | /**
99 | * Text for the event.
100 | * @param text
101 | * Event text ; supports line breaks ; mandatory
102 | * @return Builder object being used.
103 | */
104 | public Builder withText(final String text) {
105 | event.text = text;
106 | return this;
107 | }
108 |
109 | /**
110 | * Date for the event.
111 | * @param date
112 | * Assign a timestamp to the event ; Default: none (Default is the current Unix epoch timestamp when not sent)
113 | * @return Builder object being used.
114 | */
115 | public Builder withDate(final Date date) {
116 | event.millisSinceEpoch = date.getTime();
117 | return this;
118 | }
119 |
120 | /**
121 | * Date for the event.
122 | * @param millisSinceEpoch
123 | * Assign a timestamp to the event ; Default: none (Default is the current Unix epoch timestamp when not sent)
124 | * @return Builder object being used.
125 | */
126 | public Builder withDate(final long millisSinceEpoch) {
127 | event.millisSinceEpoch = millisSinceEpoch;
128 | return this;
129 | }
130 |
131 | /**
132 | * Source hostname for the event.
133 | * @param hostname
134 | * Assign a hostname to the event ; Default: none
135 | * @return Builder object being used.
136 | */
137 | public Builder withHostname(final String hostname) {
138 | event.hostname = hostname;
139 | return this;
140 | }
141 |
142 | /**
143 | * Aggregation key for the event.
144 | * @param aggregationKey
145 | * Assign an aggregation key to the event, to group it with some others ; Default: none
146 | * @return Builder object being used.
147 | */
148 | public Builder withAggregationKey(final String aggregationKey) {
149 | event.aggregationKey = aggregationKey;
150 | return this;
151 | }
152 |
153 | /**
154 | * Priority for the event.
155 | * @param priority
156 | * Can be "normal" or "low" ; Default: "normal"
157 | * @return Builder object being used.
158 | */
159 | public Builder withPriority(final Priority priority) {
160 | //noinspection StringToUpperCaseOrToLowerCaseWithoutLocale
161 | event.priority = priority.name().toLowerCase();
162 | return this;
163 | }
164 |
165 | /**
166 | * Source Type name for the event.
167 | * @param sourceTypeName
168 | * Assign a source type to the event ; Default: none
169 | * @return Builder object being used.
170 | */
171 | public Builder withSourceTypeName(final String sourceTypeName) {
172 | event.sourceTypeName = sourceTypeName;
173 | return this;
174 | }
175 |
176 | /**
177 | * Alert type for the event.
178 | * @param alertType
179 | * Can be "error", "warning", "info" or "success" ; Default: "info"
180 | * @return Builder object being used.
181 | */
182 | public Builder withAlertType(final AlertType alertType) {
183 | //noinspection StringToUpperCaseOrToLowerCaseWithoutLocale
184 | event.alertType = alertType.name().toLowerCase();
185 | return this;
186 | }
187 | }
188 | }
189 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/InvalidMessageException.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | /**
4 | * Signals that we've been passed a message that's invalid and won't be sent.
5 | *
6 | * @author Taylor Schilling
7 | */
8 |
9 | public class InvalidMessageException extends RuntimeException {
10 |
11 | private final String invalidMessage;
12 |
13 | /**
14 | * Creates an InvalidMessageException with a specified detail message and the invalid message itself.
15 | *
16 | * @param detailMessage a message that details why the invalid message is considered so
17 | * @param invalidMessage the message deemed invalid
18 | */
19 | public InvalidMessageException(final String detailMessage, final String invalidMessage) {
20 | super(detailMessage);
21 | this.invalidMessage = invalidMessage;
22 | }
23 |
24 | public String getInvalidMessage() {
25 | return invalidMessage;
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/MapUtils.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.lang.invoke.MethodHandle;
4 | import java.lang.invoke.MethodHandles;
5 | import java.lang.invoke.MethodType;
6 | import java.util.Map;
7 |
8 | /**
9 | * MethodHandle based bridge for using JDK8+ functionality at JDK7 language level.
10 | * Can be removed when support for JDK7 is dropped.
11 | */
12 | public class MapUtils {
13 |
14 | private static final MethodHandle MAP_PUT_IF_ABSENT = buildMapPutIfAbsent();
15 |
16 | /**
17 | * Emulates {@code Map.putIfAbsent} semantics. Replace when baselining at JDK8+.
18 | * @return the previous value associated with the message, or null if the value was not seen before
19 | */
20 | static Message putIfAbsent(Map map, Message message) {
21 | if (MAP_PUT_IF_ABSENT != null) {
22 | try {
23 | return (Message) (Object) MAP_PUT_IF_ABSENT.invokeExact(map, (Object) message, (Object) message);
24 | } catch (Throwable ignore) {
25 | return putIfAbsentFallback(map, message);
26 | }
27 | }
28 | return putIfAbsentFallback(map, message);
29 | }
30 |
31 | /**
32 | * Emulates {@code Map.putIfAbsent} semantics. Replace when baselining at JDK8+.
33 | * @return the previous value associated with the message, or null if the value was not seen before
34 | */
35 | private static Message putIfAbsentFallback(Map map, Message message) {
36 | if (map.containsKey(message)) {
37 | return map.get(message);
38 | }
39 | map.put(message, message);
40 | return null;
41 | }
42 |
43 | private static MethodHandle buildMapPutIfAbsent() {
44 | try {
45 | return MethodHandles.publicLookup()
46 | .findVirtual(Map.class, "putIfAbsent",
47 | MethodType.methodType(Object.class, Object.class, Object.class));
48 | } catch (Throwable ignore) {
49 | return null;
50 | }
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/Message.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.util.Arrays;
4 | import java.util.EnumSet;
5 | import java.util.Objects;
6 | import java.util.Set;
7 |
8 | public abstract class Message implements Comparable {
9 |
10 | final String aspect;
11 | final Message.Type type;
12 | final String[] tags;
13 | protected boolean done;
14 |
15 | // borrowed from Array.hashCode implementation:
16 | // https://github.com/openjdk/jdk11/blob/master/src/java.base/share/classes/java/util/Arrays.java#L4454-L4465
17 | protected static final int HASH_MULTIPLIER = 31;
18 |
19 | public enum Type {
20 | GAUGE("g"),
21 | COUNT("c"),
22 | TIME("ms"),
23 | SET("s"),
24 | HISTOGRAM("h"),
25 | DISTRIBUTION("d"),
26 | EVENT("_e"),
27 | SERVICE_CHECK("_sc");
28 |
29 | private final String type;
30 |
31 | Type(String type) {
32 | this.type = type;
33 | }
34 |
35 | public String toString() {
36 | return this.type;
37 | }
38 | }
39 |
40 | protected static final Set AGGREGATE_SET = EnumSet.of(Type.COUNT, Type.GAUGE, Type.SET);
41 |
42 | protected Message(Message.Type type) {
43 | this("", type, null);
44 | }
45 |
46 | protected Message(String aspect, Message.Type type, String[] tags) {
47 | this.aspect = aspect == null ? "" : aspect;
48 | this.type = type;
49 | this.done = false;
50 | this.tags = tags;
51 | }
52 |
53 | /**
54 | * Write this message to the provided {@link StringBuilder}. Will
55 | * be called from the sender threads.
56 | *
57 | * @param builder StringBuilder the text representation will be written to.
58 | * @param capacity The capacity of the send buffer.
59 | * @param containerID The container ID to be appended to the message.
60 | * @return boolean indicating whether the message was partially written to the builder.
61 | * If true, the method will be called again with the same arguments to continue writing.
62 | */
63 | abstract boolean writeTo(StringBuilder builder, int capacity, String containerID);
64 |
65 | /**
66 | * Aggregate message.
67 | *
68 | * @param message
69 | * Message to aggregate.
70 | */
71 | public abstract void aggregate(Message message);
72 |
73 |
74 | /**
75 | * Return the message aspect.
76 | *
77 | * @return returns the string representing the Message aspect
78 | */
79 | public final String getAspect() {
80 | return this.aspect;
81 | }
82 |
83 | /**
84 | * Return the message type.
85 | *
86 | * @return returns the dogstatsd type for the Message
87 | */
88 | public final Type getType() {
89 | return this.type;
90 | }
91 |
92 | /**
93 | * Return the array of tags for the message.
94 | *
95 | * @return returns the string array of tags for the Message
96 | */
97 | public String[] getTags() {
98 | return this.tags;
99 | }
100 |
101 | /**
102 | * Return whether a message can be aggregated.
103 | *
104 | * @return boolean on whether or not this message type may be aggregated.
105 | */
106 | public boolean canAggregate() {
107 | return AGGREGATE_SET.contains(type);
108 | }
109 |
110 | public void setDone(boolean done) {
111 | this.done = done;
112 | }
113 |
114 | public boolean getDone() {
115 | return this.done;
116 | }
117 |
118 | /**
119 | * Messages must implement hashCode.
120 | */
121 | @Override
122 | public int hashCode() {
123 | return type.hashCode() * HASH_MULTIPLIER * HASH_MULTIPLIER
124 | + aspect.hashCode() * HASH_MULTIPLIER
125 | + Arrays.hashCode(this.tags);
126 | }
127 |
128 | /**
129 | * Messages must implement hashCode.
130 | */
131 | @Override
132 | public boolean equals(Object object) {
133 | if (object == this) {
134 | return true;
135 | }
136 | if (object instanceof Message) {
137 | final Message msg = (Message)object;
138 |
139 | return (Objects.equals(this.getAspect(), msg.getAspect()))
140 | && (this.getType() == msg.getType())
141 | && Arrays.equals(this.tags, msg.getTags());
142 | }
143 |
144 | return false;
145 | }
146 |
147 | @Override
148 | public int compareTo(Message message) {
149 | int typeComparison = getType().compareTo(message.getType());
150 | if (typeComparison == 0) {
151 | int aspectComparison = getAspect().compareTo(message.getAspect());
152 | if (aspectComparison == 0) {
153 | if (tags == null && message.tags == null) {
154 | return 0;
155 | } else if (tags == null) {
156 | return 1;
157 | } else if (message.tags == null) {
158 | return -1;
159 | }
160 | if (tags.length == message.tags.length) {
161 | int comparison = 0;
162 | for (int i = 0; i < tags.length && comparison == 0; i++) {
163 | comparison = tags[i].compareTo(message.tags[i]);
164 | }
165 | return comparison;
166 | }
167 | return tags.length < message.tags.length ? 1 : -1;
168 | }
169 | return aspectComparison;
170 | }
171 | return typeComparison;
172 | }
173 | }
174 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/NamedPipeClientChannel.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.io.FileNotFoundException;
4 | import java.io.IOException;
5 | import java.io.RandomAccessFile;
6 | import java.nio.ByteBuffer;
7 | import java.nio.channels.FileChannel;
8 |
9 | class NamedPipeClientChannel implements ClientChannel {
10 | private final RandomAccessFile randomAccessFile;
11 | private final FileChannel fileChannel;
12 | private final String pipe;
13 |
14 | /**
15 | * Creates a new NamedPipeClientChannel with the given address.
16 | *
17 | * @param address Location of named pipe
18 | * @throws FileNotFoundException if pipe does not exist
19 | */
20 | NamedPipeClientChannel(NamedPipeSocketAddress address) throws FileNotFoundException {
21 | pipe = address.getPipe();
22 | randomAccessFile = new RandomAccessFile(pipe, "rw");
23 | fileChannel = randomAccessFile.getChannel();
24 | }
25 |
26 | @Override
27 | public boolean isOpen() {
28 | return fileChannel.isOpen();
29 | }
30 |
31 | @Override
32 | public int write(ByteBuffer src) throws IOException {
33 | return fileChannel.write(src);
34 | }
35 |
36 | @Override
37 | public void close() throws IOException {
38 | // closing the file also closes the channel
39 | randomAccessFile.close();
40 | }
41 |
42 | @Override
43 | public String getTransportType() {
44 | return "namedpipe";
45 | }
46 |
47 | @Override
48 | public String toString() {
49 | return pipe;
50 | }
51 |
52 | @Override
53 | public int getMaxPacketSizeBytes() {
54 | return NonBlockingStatsDClient.DEFAULT_UDS_MAX_PACKET_SIZE_BYTES;
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/NamedPipeSocketAddress.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.net.SocketAddress;
4 |
5 | public class NamedPipeSocketAddress extends SocketAddress {
6 | private static final String NAMED_PIPE_PREFIX = "\\\\.\\pipe\\";
7 | private final String pipe;
8 |
9 | public NamedPipeSocketAddress(String pipeName) {
10 | this.pipe = normalizePipeName(pipeName);
11 | }
12 |
13 | public String getPipe() {
14 | return pipe;
15 | }
16 |
17 | /**
18 | * Return true if object is a NamedPipeSocketAddress referring to the same path.
19 | */
20 | public boolean equals(Object object) {
21 | if (object instanceof NamedPipeSocketAddress) {
22 | return pipe.equals(((NamedPipeSocketAddress)object).pipe);
23 | }
24 | return false;
25 | }
26 |
27 | /**
28 | * A normalized version of the pipe name that includes the `\\.\pipe\` prefix
29 | */
30 | static String normalizePipeName(String pipeName) {
31 | if (pipeName.startsWith(NAMED_PIPE_PREFIX)) {
32 | return pipeName;
33 | } else {
34 | return NAMED_PIPE_PREFIX + pipeName;
35 | }
36 | }
37 |
38 | static boolean isNamedPipe(String address) {
39 | return address.startsWith(NAMED_PIPE_PREFIX);
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/NoOpDirectStatsDClient.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | /**
4 | * A No-Op {@link NonBlockingDirectStatsDClient}, which can be substituted in when metrics are not
5 | * required.
6 | */
7 | public class NoOpDirectStatsDClient extends NoOpStatsDClient implements DirectStatsDClient {
8 | @Override public void recordDistributionValues(String aspect, double[] values, double sampleRate, String... tags) { }
9 |
10 | @Override public void recordDistributionValues(String aspect, long[] values, double sampleRate, String... tags) { }
11 | }
12 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/NoOpStatsDClient.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | /**
4 | * A No-Op StatsDClient, which can be substituted in when metrics are not
5 | * required.
6 | *
7 | * @author Tom Denley
8 | *
9 | */
10 | public class NoOpStatsDClient implements StatsDClient {
11 |
12 | @Override public void stop() { }
13 |
14 | @Override public void close() { }
15 |
16 | @Override public void count(String aspect, long delta, String... tags) { }
17 |
18 | @Override public void count(String aspect, long delta, double sampleRate, String... tags) { }
19 |
20 | @Override public void count(String aspect, double delta, String... tags) { }
21 |
22 | @Override public void count(String aspect, double delta, double sampleRate, String... tags) { }
23 |
24 | @Override public void countWithTimestamp(String aspect, long delta, long timestamp, String... tags) { }
25 |
26 | @Override public void countWithTimestamp(String aspect, double delta, long timestamp, String... tags) { }
27 |
28 | @Override public void incrementCounter(String aspect, String... tags) { }
29 |
30 | @Override public void incrementCounter(String aspect, double sampleRate, String... tags) { }
31 |
32 | @Override public void increment(String aspect, String... tags) { }
33 |
34 | @Override public void increment(String aspect, double sampleRate, String...tags) { }
35 |
36 | @Override public void decrementCounter(String aspect, String... tags) { }
37 |
38 | @Override public void decrementCounter(String aspect, double sampleRate, String... tags) { }
39 |
40 | @Override public void decrement(String aspect, String... tags) { }
41 |
42 | @Override public void decrement(String aspect, double sampleRate, String... tags) { }
43 |
44 | @Override public void recordGaugeValue(String aspect, double value, String... tags) { }
45 |
46 | @Override public void recordGaugeValue(String aspect, double value, double sampleRate, String... tags) { }
47 |
48 | @Override public void recordGaugeValue(String aspect, long value, String... tags) { }
49 |
50 | @Override public void recordGaugeValue(String aspect, long value, double sampleRate, String... tags) { }
51 |
52 | @Override public void gauge(String aspect, double value, String... tags) { }
53 |
54 | @Override public void gauge(String aspect, double value, double sampleRate, String... tags) { }
55 |
56 | @Override public void gauge(String aspect, long value, String... tags) { }
57 |
58 | @Override public void gauge(String aspect, long value, double sampleRate, String... tags) { }
59 |
60 | @Override public void gaugeWithTimestamp(String aspect, double value, long timestamp, String... tags) { }
61 |
62 | @Override public void gaugeWithTimestamp(String aspect, long value, long timestamp, String... tags) { }
63 |
64 | @Override public void recordExecutionTime(String aspect, long timeInMs, String... tags) { }
65 |
66 | @Override public void recordExecutionTime(String aspect, long timeInMs, double sampleRate, String... tags) { }
67 |
68 | @Override public void time(String aspect, long value, String... tags) { }
69 |
70 | @Override public void time(String aspect, long value, double sampleRate, String... tags) { }
71 |
72 | @Override public void recordHistogramValue(String aspect, double value, String... tags) { }
73 |
74 | @Override public void recordHistogramValue(String aspect, double value, double sampleRate, String... tags) { }
75 |
76 | @Override public void recordHistogramValue(String aspect, long value, String... tags) { }
77 |
78 | @Override public void recordHistogramValue(String aspect, long value, double sampleRate, String... tags) { }
79 |
80 | @Override public void histogram(String aspect, double value, String... tags) { }
81 |
82 | @Override public void histogram(String aspect, double value, double sampleRate, String... tags) { }
83 |
84 | @Override public void histogram(String aspect, long value, String... tags) { }
85 |
86 | @Override public void histogram(String aspect, long value, double sampleRate, String... tags) { }
87 |
88 | @Override public void recordDistributionValue(String aspect, double value, String... tags) { }
89 |
90 | @Override public void recordDistributionValue(String aspect, double value, double sampleRate, String... tags) { }
91 |
92 | @Override public void recordDistributionValue(String aspect, long value, String... tags) { }
93 |
94 | @Override public void recordDistributionValue(String aspect, long value, double sampleRate, String... tags) { }
95 |
96 | @Override public void distribution(String aspect, double value, String... tags) { }
97 |
98 | @Override public void distribution(String aspect, double value, double sampleRate, String... tags) { }
99 |
100 | @Override public void distribution(String aspect, long value, String... tags) { }
101 |
102 | @Override public void distribution(String aspect, long value, double sampleRate, String... tags) { }
103 |
104 | @Override public void recordEvent(final Event event, final String... tags) { }
105 |
106 | @Override public void recordServiceCheckRun(ServiceCheck sc) { }
107 |
108 | @Override public void serviceCheck(ServiceCheck sc) { }
109 |
110 | @Override public void recordSetValue(String aspect, String value, String... tags) { }
111 | }
112 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/NonBlockingDirectStatsDClient.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | class NonBlockingDirectStatsDClient extends NonBlockingStatsDClient implements DirectStatsDClient {
4 |
5 | public NonBlockingDirectStatsDClient(final NonBlockingStatsDClientBuilder builder) throws StatsDClientException {
6 | super(builder);
7 | }
8 |
9 | @Override
10 | public void recordDistributionValues(String aspect, double[] values, double sampleRate, String... tags) {
11 | if (values != null && values.length > 0) {
12 | sendMetric(new DoublesStatsDMessage(aspect, Message.Type.DISTRIBUTION, values, sampleRate, 0, tags));
13 | }
14 | }
15 |
16 | @Override
17 | public void recordDistributionValues(String aspect, long[] values, double sampleRate, String... tags) {
18 | if (values != null && values.length > 0) {
19 | sendMetric(new LongsStatsDMessage(aspect, Message.Type.DISTRIBUTION, values, sampleRate, 0, tags));
20 | }
21 | }
22 |
23 | abstract class MultiValuedStatsDMessage extends Message {
24 | private final double sampleRate; // NaN for none
25 | private final long timestamp; // zero for none
26 | private int metadataSize = -1; // Cache the size of the metadata, -1 means not calculated yet
27 | private int offset = 0; // The index of the first value that has not been written
28 |
29 | MultiValuedStatsDMessage(String aspect, Message.Type type, String[] tags, double sampleRate, long timestamp) {
30 | super(aspect, type, tags);
31 | this.sampleRate = sampleRate;
32 | this.timestamp = timestamp;
33 | }
34 |
35 | @Override
36 | public final boolean canAggregate() {
37 | return false;
38 | }
39 |
40 | @Override
41 | public final void aggregate(Message message) {
42 | }
43 |
44 | @Override
45 | public final boolean writeTo(StringBuilder builder, int capacity, String containerID) {
46 | int metadataSize = metadataSize(builder, containerID);
47 | writeHeadMetadata(builder);
48 | boolean partialWrite = writeValuesTo(builder, capacity - metadataSize);
49 | writeTailMetadata(builder, containerID);
50 | return partialWrite;
51 |
52 | }
53 |
54 | private int metadataSize(StringBuilder builder, String containerID) {
55 | if (metadataSize == -1) {
56 | final int previousLength = builder.length();
57 | final int previousEncodedLength = Utf8.encodedLength(builder);
58 | writeHeadMetadata(builder);
59 | writeTailMetadata(builder, containerID);
60 | metadataSize = Utf8.encodedLength(builder) - previousEncodedLength;
61 | builder.setLength(previousLength);
62 | }
63 | return metadataSize;
64 | }
65 |
66 | private void writeHeadMetadata(StringBuilder builder) {
67 | builder.append(prefix).append(aspect);
68 | }
69 |
70 | private void writeTailMetadata(StringBuilder builder, String containerID) {
71 | builder.append('|').append(type);
72 | if (!Double.isNaN(sampleRate)) {
73 | builder.append('|').append('@').append(format(SAMPLE_RATE_FORMATTER, sampleRate));
74 | }
75 | if (timestamp != 0) {
76 | builder.append("|T").append(timestamp);
77 | }
78 | tagString(tags, builder);
79 | if (containerID != null && !containerID.isEmpty()) {
80 | builder.append("|c:").append(containerID);
81 | }
82 |
83 | builder.append('\n');
84 | }
85 |
86 | private boolean writeValuesTo(StringBuilder builder, int remainingCapacity) {
87 | if (offset >= lengthOfValues()) {
88 | return false;
89 | }
90 |
91 | int maxLength = builder.length() + remainingCapacity;
92 |
93 | // Add at least one value
94 | builder.append(':');
95 | writeValueTo(builder, offset);
96 | int previousLength = builder.length();
97 |
98 | // Add remaining values up to the max length
99 | for (int i = offset + 1; i < lengthOfValues(); i++) {
100 | builder.append(':');
101 | writeValueTo(builder, i);
102 | if (builder.length() > maxLength) {
103 | builder.setLength(previousLength);
104 | offset = i;
105 | return true;
106 | }
107 | previousLength = builder.length();
108 | }
109 | offset = lengthOfValues();
110 | return false;
111 | }
112 |
113 | protected abstract int lengthOfValues();
114 |
115 | protected abstract void writeValueTo(StringBuilder buffer, int index);
116 | }
117 |
118 | final class LongsStatsDMessage extends MultiValuedStatsDMessage {
119 | private final long[] values;
120 |
121 | LongsStatsDMessage(String aspect, Message.Type type, long[] values, double sampleRate, long timestamp, String[] tags) {
122 | super(aspect, type, tags, sampleRate, timestamp);
123 | this.values = values;
124 | }
125 |
126 | @Override
127 | protected int lengthOfValues() {
128 | return values.length;
129 | }
130 |
131 | @Override
132 | protected void writeValueTo(StringBuilder buffer, int index) {
133 | buffer.append(values[index]);
134 | }
135 | }
136 |
137 | final class DoublesStatsDMessage extends MultiValuedStatsDMessage {
138 | private final double[] values;
139 |
140 | DoublesStatsDMessage(String aspect, Message.Type type, double[] values, double sampleRate, long timestamp,
141 | String[] tags) {
142 | super(aspect, type, tags, sampleRate, timestamp);
143 | this.values = values;
144 | }
145 |
146 | @Override
147 | protected int lengthOfValues() {
148 | return values.length;
149 | }
150 |
151 | @Override
152 | protected void writeValueTo(StringBuilder buffer, int index) {
153 | buffer.append(values[index]);
154 | }
155 | }
156 | }
157 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/NumericMessage.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 |
4 | public abstract class NumericMessage extends Message {
5 |
6 | protected Number value;
7 |
8 | protected NumericMessage(Message.Type type) {
9 | super(type);
10 | }
11 |
12 | protected NumericMessage(String aspect, Message.Type type, T value, String[] tags) {
13 | super(aspect, type, tags);
14 | this.value = value;
15 | }
16 |
17 |
18 | /**
19 | * Aggregate message.
20 | *
21 | * @param message
22 | * Message to aggregate.
23 | */
24 | @Override
25 | public void aggregate(Message message) {
26 | NumericMessage msg = (NumericMessage)message;
27 | Number value = msg.getValue();
28 | switch (msg.getType()) {
29 | case GAUGE:
30 | setValue(value);
31 | break;
32 | default:
33 | if (value instanceof Double) {
34 | setValue(getValue().doubleValue() + value.doubleValue());
35 | } else if (value instanceof Integer) {
36 | setValue(getValue().intValue() + value.intValue());
37 | } else if (value instanceof Long) {
38 | setValue(getValue().longValue() + value.longValue());
39 | }
40 | }
41 |
42 | return;
43 | }
44 |
45 | /**
46 | * Get underlying message value.
47 | *
48 | * @return returns the value for the Message
49 | */
50 | public Number getValue() {
51 | return this.value;
52 | }
53 |
54 | /**
55 | * Set underlying message value.
56 | *
57 | * @param value the numeric value for the underlying message
58 | */
59 | public void setValue(Number value) {
60 | this.value = value;
61 | }
62 |
63 | }
64 |
65 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/ServiceCheck.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | /**
4 | * A service check model, which is used to format a service check message
5 | * sent to the datadog agent.
6 | */
7 | public class ServiceCheck {
8 |
9 | public enum Status {
10 | OK(0), WARNING(1), CRITICAL(2), UNKNOWN(3);
11 |
12 | private final int val;
13 | Status(final int val) {
14 | this.val = val;
15 | }
16 | }
17 |
18 | private String name;
19 | private String hostname;
20 | private String message;
21 |
22 | private int checkRunId;
23 | private int timestamp;
24 |
25 | private Status status;
26 |
27 | private String[] tags;
28 |
29 | public static Builder builder() {
30 | return new Builder();
31 | }
32 |
33 | public static class Builder {
34 | final ServiceCheck res = new ServiceCheck();
35 |
36 | public Builder withName(final String name) {
37 | res.name = name;
38 | return this;
39 | }
40 |
41 | public Builder withHostname(final String hostname) {
42 | res.hostname = hostname;
43 | return this;
44 | }
45 |
46 | public Builder withMessage(final String message) {
47 | res.message = message;
48 | return this;
49 | }
50 |
51 | public Builder withCheckRunId(final int checkRunId) {
52 | res.checkRunId = checkRunId;
53 | return this;
54 | }
55 |
56 | public Builder withTimestamp(final int timestamp) {
57 | res.timestamp = timestamp;
58 | return this;
59 | }
60 |
61 | public Builder withStatus(final Status status) {
62 | res.status = status;
63 | return this;
64 | }
65 |
66 | public Builder withTags(final String[] tags) {
67 | res.tags = tags;
68 | return this;
69 | }
70 |
71 | public ServiceCheck build() {
72 | return res;
73 | }
74 | }
75 |
76 | private ServiceCheck() {
77 | }
78 |
79 | public String getName() {
80 | return name;
81 | }
82 |
83 | public int getStatus() {
84 | return status.val;
85 | }
86 |
87 | public String getMessage() {
88 | return message;
89 | }
90 |
91 | public String getEscapedMessage() {
92 | return message.replace("\n", "\\n").replace("m:", "m\\:");
93 | }
94 |
95 | public String getHostname() {
96 | return hostname;
97 | }
98 |
99 | public int getTimestamp() {
100 | return timestamp;
101 | }
102 |
103 | public String[] getTags() {
104 | return tags;
105 | }
106 | }
107 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/StatsDAggregator.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.util.ArrayList;
4 | import java.util.HashMap;
5 | import java.util.Iterator;
6 | import java.util.Map;
7 | import java.util.Timer;
8 | import java.util.TimerTask;
9 |
10 |
11 | public class StatsDAggregator {
12 | public static int DEFAULT_FLUSH_INTERVAL = 2000; // 2s
13 | public static int DEFAULT_SHARDS = 4; // 4 partitions to reduce contention.
14 |
15 | protected final String AGGREGATOR_THREAD_NAME = "statsd-aggregator-thread";
16 | protected final ArrayList> aggregateMetrics;
17 |
18 | protected final int shardGranularity;
19 | protected final long flushInterval;
20 |
21 | private final StatsDProcessor processor;
22 |
23 | protected Timer scheduler = null;
24 |
25 | private Telemetry telemetry;
26 |
27 | private class FlushTask extends TimerTask {
28 | @Override
29 | public void run() {
30 | flush();
31 | }
32 | }
33 |
34 | /**
35 | * StatsDAggregtor constructor.
36 | *
37 | * @param processor the message processor, aggregated messages will be queued in the high priority queue.
38 | * @param shards number of shards for the aggregation map.
39 | * @param flushInterval flush interval in miliseconds, 0 disables message aggregation.
40 | *
41 | * */
42 | public StatsDAggregator(final StatsDProcessor processor, final int shards, final long flushInterval) {
43 | this.processor = processor;
44 | this.flushInterval = flushInterval;
45 | this.shardGranularity = shards;
46 | this.aggregateMetrics = new ArrayList<>(shards);
47 |
48 | if (flushInterval > 0) {
49 | this.scheduler = new Timer(AGGREGATOR_THREAD_NAME, true);
50 | }
51 |
52 | for (int i = 0 ; i < this.shardGranularity ; i++) {
53 | this.aggregateMetrics.add(i, new HashMap());
54 | }
55 | }
56 |
57 | /**
58 | * Start the aggregator flushing scheduler.
59 | *
60 | * */
61 | public void start() {
62 | if (flushInterval > 0) {
63 | // snapshot of processor telemetry - avoid volatile reference to harness CPU cache
64 | // caller responsible of setting telemetry before starting
65 | telemetry = processor.getTelemetry();
66 | scheduler.scheduleAtFixedRate(new FlushTask(), flushInterval, flushInterval);
67 | }
68 | }
69 |
70 | /**
71 | * Stop the aggregator flushing scheduler.
72 | *
73 | * */
74 | public void stop() {
75 | if (flushInterval > 0) {
76 | scheduler.cancel();
77 | }
78 | }
79 |
80 | /**
81 | * Aggregate a message if possible.
82 | *
83 | * @param message the dogstatsd Message we wish to aggregate.
84 | * @return a boolean reflecting if the message was aggregated.
85 | *
86 | * */
87 | public boolean aggregateMessage(Message message) {
88 | if (flushInterval == 0 || !message.canAggregate() || message.getDone()) {
89 | return false;
90 | }
91 |
92 |
93 | int hash = message.hashCode();
94 | int bucket = Math.abs(hash % this.shardGranularity);
95 | Map map = aggregateMetrics.get(bucket);
96 |
97 | synchronized (map) {
98 | // For now let's just put the message in the map
99 | Message msg = MapUtils.putIfAbsent(map, message);
100 | if (msg != null) {
101 | msg.aggregate(message);
102 | if (telemetry != null) {
103 | telemetry.incrAggregatedContexts(1);
104 |
105 | // developer metrics
106 | switch (message.getType()) {
107 | case GAUGE:
108 | telemetry.incrAggregatedGaugeContexts(1);
109 | break;
110 | case COUNT:
111 | telemetry.incrAggregatedCountContexts(1);
112 | break;
113 | case SET:
114 | telemetry.incrAggregatedSetContexts(1);
115 | break;
116 | default:
117 | break;
118 | }
119 | }
120 | }
121 | }
122 |
123 | return true;
124 | }
125 |
126 | public final long getFlushInterval() {
127 | return this.flushInterval;
128 | }
129 |
130 | public final int getShardGranularity() {
131 | return this.shardGranularity;
132 | }
133 |
134 | protected void flush() {
135 | for (int i = 0 ; i < shardGranularity ; i++) {
136 | Map map = aggregateMetrics.get(i);
137 |
138 | synchronized (map) {
139 | Iterator> iter = map.entrySet().iterator();
140 | while (iter.hasNext()) {
141 | Message msg = iter.next().getValue();
142 | msg.setDone(true);
143 |
144 | if (!processor.sendHighPrio(msg) && (telemetry != null)) {
145 | telemetry.incrPacketDroppedQueue(1);
146 | }
147 |
148 | iter.remove();
149 | }
150 | }
151 | }
152 | }
153 | }
154 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/StatsDBlockingProcessor.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import com.timgroup.statsd.Message;
4 |
5 | import java.nio.BufferOverflowException;
6 | import java.nio.ByteBuffer;
7 | import java.util.concurrent.ArrayBlockingQueue;
8 | import java.util.concurrent.BlockingQueue;
9 | import java.util.concurrent.ThreadFactory;
10 | import java.util.concurrent.TimeUnit;
11 |
12 |
13 | public class StatsDBlockingProcessor extends StatsDProcessor {
14 |
15 | private final BlockingQueue messages;
16 |
17 | private class ProcessingTask extends StatsDProcessor.ProcessingTask {
18 |
19 | @Override
20 | protected Message getMessage() throws InterruptedException {
21 | return messages.poll(WAIT_SLEEP_MS, TimeUnit.MILLISECONDS);
22 | }
23 |
24 | @Override
25 | protected boolean haveMessages() {
26 | return !messages.isEmpty();
27 | }
28 | }
29 |
30 | StatsDBlockingProcessor(final int queueSize, final StatsDClientErrorHandler handler,
31 | final int maxPacketSizeBytes, final int poolSize, final int workers,
32 | final int aggregatorFlushInterval, final int aggregatorShards,
33 | final ThreadFactory threadFactory, final String containerID) throws Exception {
34 |
35 | super(queueSize, handler, maxPacketSizeBytes, poolSize, workers,
36 | aggregatorFlushInterval, aggregatorShards, threadFactory, containerID);
37 | this.messages = new ArrayBlockingQueue<>(queueSize);
38 | }
39 |
40 | @Override
41 | protected ProcessingTask createProcessingTask() {
42 | return new ProcessingTask();
43 | }
44 |
45 | @Override
46 | protected boolean send(final Message message) {
47 | try {
48 | if (!shutdown) {
49 | messages.put(message);
50 | return true;
51 | }
52 | } catch (InterruptedException e) {
53 | // NOTHING
54 | }
55 |
56 | return false;
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/StatsDClientErrorHandler.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | /**
4 | * Describes a handler capable of processing exceptions that occur during StatsD client operations.
5 | *
6 | * @author Tom Denley
7 | *
8 | */
9 | public interface StatsDClientErrorHandler {
10 |
11 | /**
12 | * Handle the given exception, which occurred during a StatsD client operation.
13 | *
14 | * Should normally be implemented as a synchronized method.
15 | *
16 | * @param exception
17 | * the {@link Exception} that occurred
18 | */
19 | void handle(Exception exception);
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/StatsDClientException.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 |
4 | /**
5 | * Signals that an exception has occurred when trying to start the
6 | * StatsD client.
7 | *
8 | * @author Tom Denley
9 | *
10 | */
11 | public final class StatsDClientException extends RuntimeException {
12 |
13 | private static final long serialVersionUID = 3186887620964773839L;
14 |
15 | public StatsDClientException() {
16 | super();
17 | }
18 |
19 | public StatsDClientException(String message, Throwable cause) {
20 | super(message, cause);
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/StatsDNonBlockingProcessor.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import com.timgroup.statsd.Message;
4 |
5 | import java.nio.BufferOverflowException;
6 | import java.nio.ByteBuffer;
7 | import java.util.Queue;
8 | import java.util.concurrent.ConcurrentLinkedQueue;
9 | import java.util.concurrent.ThreadFactory;
10 | import java.util.concurrent.atomic.AtomicInteger;
11 |
12 |
13 | public class StatsDNonBlockingProcessor extends StatsDProcessor {
14 |
15 | private final Queue messages;
16 | private final AtomicInteger qsize; // qSize will not reflect actual size, but a close estimate.
17 |
18 | private class ProcessingTask extends StatsDProcessor.ProcessingTask {
19 | @Override
20 | protected Message getMessage() throws InterruptedException {
21 | final Message message = messages.poll();
22 | if (message != null) {
23 | qsize.decrementAndGet();
24 | return message;
25 | }
26 |
27 | Thread.sleep(WAIT_SLEEP_MS);
28 |
29 | return null;
30 | }
31 |
32 | @Override
33 | protected boolean haveMessages() {
34 | return !messages.isEmpty();
35 | }
36 | }
37 |
38 | StatsDNonBlockingProcessor(final int queueSize, final StatsDClientErrorHandler handler,
39 | final int maxPacketSizeBytes, final int poolSize, final int workers,
40 | final int aggregatorFlushInterval, final int aggregatorShards,
41 | final ThreadFactory threadFactory, final String containerID) throws Exception {
42 |
43 | super(queueSize, handler, maxPacketSizeBytes, poolSize, workers,
44 | aggregatorFlushInterval, aggregatorShards, threadFactory, containerID);
45 | this.qsize = new AtomicInteger(0);
46 | this.messages = new ConcurrentLinkedQueue<>();
47 | }
48 |
49 | @Override
50 | protected ProcessingTask createProcessingTask() {
51 | return new ProcessingTask();
52 | }
53 |
54 | @Override
55 | protected boolean send(final Message message) {
56 | if (!shutdown) {
57 | if (qsize.get() < qcapacity) {
58 | messages.offer(message);
59 | qsize.incrementAndGet();
60 | return true;
61 | }
62 | }
63 |
64 | return false;
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/StatsDProcessor.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import com.timgroup.statsd.Message;
4 |
5 | import java.nio.BufferOverflowException;
6 | import java.nio.ByteBuffer;
7 |
8 | import java.util.Queue;
9 | import java.util.concurrent.ArrayBlockingQueue;
10 | import java.util.concurrent.BlockingQueue;
11 | import java.util.concurrent.ConcurrentLinkedQueue;
12 | import java.util.concurrent.CountDownLatch;
13 | import java.util.concurrent.ThreadFactory;
14 | import java.util.concurrent.TimeUnit;
15 | import java.util.concurrent.atomic.AtomicInteger;
16 |
17 | public abstract class StatsDProcessor {
18 | protected static final String MESSAGE_TOO_LONG = "Message longer than size of sendBuffer";
19 | protected static final int WAIT_SLEEP_MS = 10; // 10 ms would be a 100HZ slice
20 |
21 | protected final StatsDClientErrorHandler handler;
22 |
23 | final int maxPacketSizeBytes;
24 | protected final BufferPool bufferPool;
25 | protected final Queue highPrioMessages; // FIFO queue for high priority messages
26 | protected final BlockingQueue outboundQueue; // FIFO queue with outbound buffers
27 | protected final CountDownLatch endSignal;
28 | final CountDownLatch closeSignal;
29 |
30 | protected final ThreadFactory threadFactory;
31 | protected final Thread[] workers;
32 | protected final int qcapacity;
33 |
34 | protected StatsDAggregator aggregator;
35 | protected volatile Telemetry telemetry;
36 |
37 | protected volatile boolean shutdown;
38 | volatile boolean shutdownAgg;
39 |
40 | String containerID;
41 |
42 | protected abstract class ProcessingTask implements Runnable {
43 | protected StringBuilder builder = new StringBuilder();
44 | char[] charBuffer = new char[maxPacketSizeBytes];
45 | // + 4 so that we can check for buffer overflow without computing encoded length first
46 | final byte[] byteBuffer = new byte[maxPacketSizeBytes + 4];
47 |
48 | public final void run() {
49 | try {
50 | processLoop();
51 | } finally {
52 | endSignal.countDown();
53 | }
54 | }
55 |
56 | protected void processLoop() {
57 | ByteBuffer sendBuffer;
58 |
59 | try {
60 | sendBuffer = bufferPool.borrow();
61 | } catch (final InterruptedException e) {
62 | return;
63 | }
64 |
65 | boolean clientClosed = false;
66 | while (!Thread.interrupted()) {
67 | try {
68 | // Read flags before polling for messages. We can continue shutdown only when
69 | // shutdown flag is true *before* we get empty result from the queue. Shadow
70 | // the names, so we can't check the non-local copy by accident.
71 | boolean shutdown = StatsDProcessor.this.shutdown;
72 | boolean shutdownAgg = StatsDProcessor.this.shutdownAgg;
73 |
74 | Message message = highPrioMessages.poll();
75 | if (message == null && shutdownAgg) {
76 | break;
77 | }
78 | if (message == null && !clientClosed) {
79 | message = getMessage();
80 | }
81 | if (message == null) {
82 | if (shutdown && !clientClosed) {
83 | closeSignal.countDown();
84 | clientClosed = true;
85 | }
86 | if (clientClosed) {
87 | // We are draining highPrioMessages, which is a non-blocking
88 | // queue. Avoid a busy loop if the queue is empty while the aggregator
89 | // is flushing.
90 | Thread.sleep(WAIT_SLEEP_MS);
91 | }
92 | continue;
93 | }
94 |
95 | if (aggregator.aggregateMessage(message)) {
96 | continue;
97 | }
98 |
99 | boolean partialWrite;
100 | do {
101 | builder.setLength(0);
102 | partialWrite = message.writeTo(builder, sendBuffer.capacity(), containerID);
103 | int lowerBoundSize = builder.length();
104 |
105 | if (sendBuffer.capacity() < lowerBoundSize) {
106 | throw new InvalidMessageException(MESSAGE_TOO_LONG, builder.toString());
107 | }
108 |
109 | if (sendBuffer.remaining() < (lowerBoundSize + 1)) {
110 | outboundQueue.put(sendBuffer);
111 | sendBuffer = bufferPool.borrow();
112 | }
113 |
114 | try {
115 | writeBuilderToSendBuffer(sendBuffer);
116 | } catch (BufferOverflowException boe) {
117 | outboundQueue.put(sendBuffer);
118 | sendBuffer = bufferPool.borrow();
119 | writeBuilderToSendBuffer(sendBuffer);
120 | }
121 | }
122 | while (partialWrite);
123 |
124 | if (!haveMessages()) {
125 | outboundQueue.put(sendBuffer);
126 | sendBuffer = bufferPool.borrow();
127 | }
128 | } catch (final InterruptedException e) {
129 | break;
130 | } catch (final Exception e) {
131 | handler.handle(e);
132 | }
133 | }
134 |
135 | builder.setLength(0);
136 | builder.trimToSize();
137 | }
138 |
139 | abstract boolean haveMessages();
140 |
141 | abstract Message getMessage() throws InterruptedException;
142 |
143 | protected void writeBuilderToSendBuffer(ByteBuffer sendBuffer) {
144 | int length = builder.length();
145 | if (length > charBuffer.length) {
146 | charBuffer = new char[length];
147 | }
148 |
149 | // We trust this returns valid UTF-16.
150 | builder.getChars(0, length, charBuffer, 0);
151 |
152 | int blen = 0;
153 | for (int i = 0; i < length; i++) {
154 | char ch = charBuffer[i];
155 | // https://en.wikipedia.org/wiki/UTF-8#Description
156 | // https://en.wikipedia.org/wiki/UTF-16#Description
157 | if (ch < 0x80) {
158 | byteBuffer[blen++] = (byte)ch;
159 | } else if (ch < 0x800) {
160 | byteBuffer[blen++] = (byte)(192 | (ch >> 6));
161 | byteBuffer[blen++] = (byte)(128 | (ch & 63));
162 | } else if (ch < 0xd800 || ch >= 0xe000) {
163 | byteBuffer[blen++] = (byte)(224 | (ch >> 12));
164 | byteBuffer[blen++] = (byte)(128 | ((ch >> 6) & 63));
165 | byteBuffer[blen++] = (byte)(128 | (ch & 63));
166 | } else {
167 | // surrogate pair
168 | int decoded = ((ch & 0x3ff) << 10) | (charBuffer[++i] & 0x3ff) | 0x10000;
169 | byteBuffer[blen++] = (byte)(240 | (decoded >> 18));
170 | byteBuffer[blen++] = (byte)(128 | ((decoded >> 12) & 63));
171 | byteBuffer[blen++] = (byte)(128 | ((decoded >> 6) & 63));
172 | byteBuffer[blen++] = (byte)(128 | (decoded & 63));
173 | }
174 |
175 | if (blen >= maxPacketSizeBytes) {
176 | throw new BufferOverflowException();
177 | }
178 | }
179 |
180 | sendBuffer.mark();
181 | sendBuffer.put(byteBuffer, 0, blen);
182 | }
183 | }
184 |
185 | StatsDProcessor(final int queueSize, final StatsDClientErrorHandler handler,
186 | final int maxPacketSizeBytes, final int poolSize, final int workers,
187 | final int aggregatorFlushInterval, final int aggregatorShards,
188 | final ThreadFactory threadFactory, final String containerID) throws Exception {
189 |
190 | this.handler = handler;
191 | this.threadFactory = threadFactory;
192 | this.workers = new Thread[workers];
193 | this.qcapacity = queueSize;
194 |
195 | this.maxPacketSizeBytes = maxPacketSizeBytes;
196 | this.bufferPool = new BufferPool(poolSize, maxPacketSizeBytes, true);
197 | this.highPrioMessages = new ConcurrentLinkedQueue<>();
198 | this.outboundQueue = new ArrayBlockingQueue(poolSize);
199 | this.endSignal = new CountDownLatch(workers);
200 | this.closeSignal = new CountDownLatch(workers);
201 | this.aggregator = new StatsDAggregator(this, aggregatorShards, aggregatorFlushInterval);
202 |
203 | this.containerID = containerID;
204 | }
205 |
206 | protected abstract ProcessingTask createProcessingTask();
207 |
208 | protected abstract boolean send(final Message message);
209 |
210 | protected boolean sendHighPrio(final Message message) {
211 | highPrioMessages.offer(message);
212 | return true;
213 | }
214 |
215 | public BufferPool getBufferPool() {
216 | return this.bufferPool;
217 | }
218 |
219 | public BlockingQueue getOutboundQueue() {
220 | return this.outboundQueue;
221 | }
222 |
223 | public int getQcapacity() {
224 | return this.qcapacity;
225 | }
226 |
227 | void startWorkers(final String namePrefix) {
228 | aggregator.start();
229 | // each task is a busy loop taking up one thread, so keep it simple and use an array of threads
230 | for (int i = 0 ; i < workers.length ; i++) {
231 | workers[i] = threadFactory.newThread(createProcessingTask());
232 | workers[i].setName(namePrefix + (i + 1));
233 | workers[i].start();
234 | }
235 | }
236 |
237 | public StatsDAggregator getAggregator() {
238 | return this.aggregator;
239 | }
240 |
241 | public void setTelemetry(final Telemetry telemetry) {
242 | this.telemetry = telemetry;
243 | }
244 |
245 | public Telemetry getTelemetry() {
246 | return telemetry;
247 | }
248 |
249 | void shutdown(boolean blocking) throws InterruptedException {
250 | shutdown = true;
251 | aggregator.stop();
252 |
253 | if (blocking) {
254 | // Wait for messages to pass through the queues and the aggregator. Shutdown logic for
255 | // each queue follows the same pattern:
256 | //
257 | // if queue returns no messages after a shutdown flag is set, assume no new messages
258 | // will arrive and count down the latch.
259 | //
260 | // This may drop messages if send is called concurrently with shutdown (even in
261 | // blocking mode); but we will (attempt to) deliver everything that was sent before
262 | // this point.
263 | closeSignal.await();
264 | aggregator.flush();
265 | shutdownAgg = true;
266 | endSignal.await();
267 | } else {
268 | // Stop all workers immediately.
269 | for (int i = 0 ; i < workers.length ; i++) {
270 | workers[i].interrupt();
271 | }
272 | }
273 | }
274 | }
275 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/StatsDSender.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.io.IOException;
4 | import java.net.SocketAddress;
5 | import java.nio.ByteBuffer;
6 | import java.nio.channels.DatagramChannel;
7 | import java.nio.channels.WritableByteChannel;
8 | import java.util.concurrent.BlockingQueue;
9 | import java.util.concurrent.Callable;
10 | import java.util.concurrent.CountDownLatch;
11 | import java.util.concurrent.ThreadFactory;
12 | import java.util.concurrent.TimeUnit;
13 | import java.util.concurrent.atomic.AtomicInteger;
14 |
15 | public class StatsDSender {
16 | private final WritableByteChannel clientChannel;
17 | private final StatsDClientErrorHandler handler;
18 |
19 | private final BufferPool pool;
20 | private final BlockingQueue buffers;
21 | private static final int WAIT_SLEEP_MS = 10; // 10 ms would be a 100HZ slice
22 |
23 | protected final ThreadFactory threadFactory;
24 | protected final Thread[] workers;
25 |
26 | private final CountDownLatch endSignal;
27 | private volatile boolean shutdown;
28 |
29 | private volatile Telemetry telemetry;
30 |
31 |
32 | StatsDSender(final WritableByteChannel clientChannel,
33 | final StatsDClientErrorHandler handler, BufferPool pool, BlockingQueue buffers,
34 | final int workers, final ThreadFactory threadFactory) {
35 |
36 | this.pool = pool;
37 | this.buffers = buffers;
38 | this.handler = handler;
39 | this.threadFactory = threadFactory;
40 | this.workers = new Thread[workers];
41 |
42 | this.clientChannel = clientChannel;
43 |
44 | this.endSignal = new CountDownLatch(workers);
45 | }
46 |
47 | public void setTelemetry(final Telemetry telemetry) {
48 | this.telemetry = telemetry;
49 | }
50 |
51 | public Telemetry getTelemetry() {
52 | return telemetry;
53 | }
54 |
55 | void startWorkers(final String namePrefix) {
56 | // each task is a busy loop taking up one thread, so keep it simple and use an array of threads
57 | for (int i = 0 ; i < workers.length ; i++) {
58 | workers[i] = threadFactory.newThread(new Runnable() {
59 | public void run() {
60 | try {
61 | sendLoop();
62 | } finally {
63 | endSignal.countDown();
64 | }
65 | }
66 | });
67 | workers[i].setName(namePrefix + (i + 1));
68 | workers[i].start();
69 | }
70 | }
71 |
72 | void sendLoop() {
73 | ByteBuffer buffer = null;
74 | Telemetry telemetry = getTelemetry(); // attribute snapshot to harness CPU cache
75 |
76 | while (!(buffers.isEmpty() && shutdown)) {
77 | int sizeOfBuffer = 0;
78 | try {
79 |
80 | if (buffer != null) {
81 | buffer.clear();
82 | pool.put(buffer);
83 | }
84 |
85 | buffer = buffers.poll(WAIT_SLEEP_MS, TimeUnit.MILLISECONDS);
86 | if (buffer == null) {
87 | continue;
88 | }
89 |
90 | sizeOfBuffer = buffer.position();
91 |
92 | buffer.flip();
93 | final int sentBytes = clientChannel.write(buffer);
94 |
95 | if (sizeOfBuffer != sentBytes) {
96 | throw new IOException(
97 | String.format("Could not send stat %s entirely to %s. Only sent %d out of %d bytes",
98 | buffer,
99 | clientChannel,
100 | sentBytes,
101 | sizeOfBuffer));
102 | }
103 |
104 | if (telemetry != null) {
105 | telemetry.incrBytesSent(sizeOfBuffer);
106 | telemetry.incrPacketSent(1);
107 | }
108 |
109 | } catch (final InterruptedException e) {
110 | if (shutdown) {
111 | break;
112 | }
113 | } catch (final Exception e) {
114 | if (telemetry != null) {
115 | telemetry.incrBytesDropped(sizeOfBuffer);
116 | telemetry.incrPacketDropped(1);
117 | }
118 | handler.handle(e);
119 | }
120 | }
121 | }
122 |
123 | void shutdown(boolean blocking) throws InterruptedException {
124 | shutdown = true;
125 | if (blocking) {
126 | endSignal.await();
127 | } else {
128 | for (int i = 0 ; i < workers.length ; i++) {
129 | workers[i].interrupt();
130 | }
131 | }
132 | }
133 | }
134 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/StatsDThreadFactory.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.util.concurrent.Executors;
4 | import java.util.concurrent.ThreadFactory;
5 |
6 | final class StatsDThreadFactory implements ThreadFactory {
7 | private final ThreadFactory delegate = Executors.defaultThreadFactory();
8 |
9 | @Override
10 | public Thread newThread(final Runnable runnable) {
11 | final Thread result = delegate.newThread(runnable);
12 | result.setName("StatsD-" + result.getName());
13 | result.setDaemon(true);
14 | return result;
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/UnixDatagramClientChannel.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import jnr.unixsocket.UnixDatagramChannel;
4 | import jnr.unixsocket.UnixSocketOptions;
5 |
6 | import java.io.IOException;
7 | import java.net.SocketAddress;
8 |
9 | class UnixDatagramClientChannel extends DatagramClientChannel {
10 | /**
11 | * Creates a new UnixDatagramClientChannel.
12 | *
13 | * @param address Address to connect the channel to
14 | * @param timeout Send timeout
15 | * @param bufferSize Buffer size
16 | * @throws IOException if socket options cannot be set
17 | */
18 | UnixDatagramClientChannel(SocketAddress address, int timeout, int bufferSize) throws IOException {
19 | super(UnixDatagramChannel.open(), address);
20 | // Set send timeout, to handle the case where the transmission buffer is full
21 | // If no timeout is set, the send becomes blocking
22 | if (timeout > 0) {
23 | delegate.setOption(UnixSocketOptions.SO_SNDTIMEO, timeout);
24 | }
25 | if (bufferSize > 0) {
26 | delegate.setOption(UnixSocketOptions.SO_SNDBUF, bufferSize);
27 | }
28 | }
29 |
30 | @Override
31 | public String getTransportType() {
32 | return "uds";
33 | }
34 |
35 | @Override
36 | public int getMaxPacketSizeBytes() {
37 | return NonBlockingStatsDClient.DEFAULT_UDS_MAX_PACKET_SIZE_BYTES;
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/UnixSocketAddressWithTransport.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.net.SocketAddress;
4 | import java.util.Objects;
5 |
6 | public class UnixSocketAddressWithTransport extends SocketAddress {
7 |
8 | private final SocketAddress address;
9 | private final TransportType transportType;
10 |
11 | public enum TransportType {
12 | UDS_STREAM("uds-stream"),
13 | UDS_DATAGRAM("uds-datagram"),
14 | UDS("uds");
15 |
16 | private final String transportType;
17 |
18 | TransportType(String transportType) {
19 | this.transportType = transportType;
20 | }
21 |
22 | String getTransportType() {
23 | return transportType;
24 | }
25 |
26 | static TransportType fromScheme(String scheme) {
27 | switch (scheme) {
28 | case "unixstream":
29 | return UDS_STREAM;
30 | case "unixgram":
31 | return UDS_DATAGRAM;
32 | case "unix":
33 | return UDS;
34 | default:
35 | break;
36 | }
37 | throw new IllegalArgumentException("Unknown scheme: " + scheme);
38 | }
39 | }
40 |
41 | public UnixSocketAddressWithTransport(final SocketAddress address, final TransportType transportType) {
42 | this.address = address;
43 | this.transportType = transportType;
44 | }
45 |
46 | @Override
47 | public boolean equals(Object other) {
48 | if (this == other) {
49 | return true;
50 | }
51 | if (other == null || getClass() != other.getClass()) {
52 | return false;
53 | }
54 | UnixSocketAddressWithTransport that = (UnixSocketAddressWithTransport) other;
55 | return Objects.equals(address, that.address) && transportType == that.transportType;
56 | }
57 |
58 | @Override
59 | public int hashCode() {
60 | return Objects.hash(address, transportType);
61 | }
62 |
63 | SocketAddress getAddress() {
64 | return address;
65 | }
66 |
67 | TransportType getTransportType() {
68 | return transportType;
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/UnixStreamClientChannel.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import jnr.unixsocket.UnixSocketAddress;
4 | import jnr.unixsocket.UnixSocketChannel;
5 | import jnr.unixsocket.UnixSocketOptions;
6 |
7 | import java.io.IOException;
8 | import java.net.SocketAddress;
9 | import java.nio.ByteBuffer;
10 | import java.nio.ByteOrder;
11 | import java.nio.channels.SocketChannel;
12 |
13 | /**
14 | * A ClientChannel for Unix domain sockets.
15 | */
16 | public class UnixStreamClientChannel implements ClientChannel {
17 | private final UnixSocketAddress address;
18 | private final int timeout;
19 | private final int connectionTimeout;
20 | private final int bufferSize;
21 |
22 |
23 | private SocketChannel delegate;
24 | private final ByteBuffer delimiterBuffer = ByteBuffer.allocateDirect(Integer.SIZE / Byte.SIZE).order(ByteOrder.LITTLE_ENDIAN);
25 |
26 | /**
27 | * Creates a new NamedPipeClientChannel with the given address.
28 | *
29 | * @param address Location of named pipe
30 | */
31 | UnixStreamClientChannel(SocketAddress address, int timeout, int connectionTimeout, int bufferSize) throws IOException {
32 | this.delegate = null;
33 | this.address = (UnixSocketAddress) address;
34 | this.timeout = timeout;
35 | this.connectionTimeout = connectionTimeout;
36 | this.bufferSize = bufferSize;
37 | }
38 |
39 | @Override
40 | public boolean isOpen() {
41 | return delegate.isConnected();
42 | }
43 |
44 | @Override
45 | public synchronized int write(ByteBuffer src) throws IOException {
46 | connectIfNeeded();
47 |
48 | int size = src.remaining();
49 | int written = 0;
50 | if (size == 0) {
51 | return 0;
52 | }
53 | delimiterBuffer.clear();
54 | delimiterBuffer.putInt(size);
55 | delimiterBuffer.flip();
56 |
57 | try {
58 | long deadline = System.nanoTime() + timeout * 1_000_000L;
59 | written = writeAll(delimiterBuffer, true, deadline);
60 | if (written > 0) {
61 | written += writeAll(src, false, deadline);
62 | }
63 | } catch (IOException e) {
64 | // If we get an exception, it's unrecoverable, we close the channel and try to reconnect
65 | disconnect();
66 | throw e;
67 | }
68 |
69 | // If we haven't written anything, we have a timeout
70 | if (written == 0) {
71 | throw new IOException("Write timed out");
72 | }
73 |
74 | return size;
75 | }
76 |
77 | /**
78 | * Writes all bytes from the given buffer to the channel.
79 | * @param bb buffer to write
80 | * @param canReturnOnTimeout if true, we return if the channel is blocking and we haven't written anything yet
81 | * @param deadline deadline for the write
82 | * @return number of bytes written
83 | * @throws IOException if the channel is closed or an error occurs
84 | */
85 | public int writeAll(ByteBuffer bb, boolean canReturnOnTimeout, long deadline) throws IOException {
86 | int remaining = bb.remaining();
87 | int written = 0;
88 | while (remaining > 0) {
89 | int read = delegate.write(bb);
90 |
91 | // If we haven't written anything yet, we can still return
92 | if (read == 0 && canReturnOnTimeout && written == 0) {
93 | return written;
94 | }
95 |
96 | remaining -= read;
97 | written += read;
98 |
99 | if (deadline > 0 && System.nanoTime() > deadline) {
100 | throw new IOException("Write timed out");
101 | }
102 | }
103 | return written;
104 | }
105 |
106 | private void connectIfNeeded() throws IOException {
107 | if (delegate == null) {
108 | connect();
109 | }
110 | }
111 |
112 | private void disconnect() throws IOException {
113 | if (delegate != null) {
114 | delegate.close();
115 | delegate = null;
116 | }
117 | }
118 |
119 | private void connect() throws IOException {
120 | if (this.delegate != null) {
121 | try {
122 | disconnect();
123 | } catch (IOException e) {
124 | // ignore to be sure we don't stay with a broken delegate forever.
125 | }
126 | }
127 |
128 | UnixSocketChannel delegate = UnixSocketChannel.create();
129 |
130 | long deadline = System.nanoTime() + connectionTimeout * 1_000_000L;
131 | if (connectionTimeout > 0) {
132 | // Set connect timeout, this should work at least on linux
133 | // https://elixir.bootlin.com/linux/v5.7.4/source/net/unix/af_unix.c#L1696
134 | // We'd have better timeout support if we used Java 16's native Unix domain socket support (JEP 380)
135 | delegate.setOption(UnixSocketOptions.SO_SNDTIMEO, connectionTimeout);
136 | }
137 | try {
138 | if (!delegate.connect(address)) {
139 | if (connectionTimeout > 0 && System.nanoTime() > deadline) {
140 | throw new IOException("Connection timed out");
141 | }
142 | if (!delegate.finishConnect()) {
143 | throw new IOException("Connection failed");
144 | }
145 | }
146 |
147 | delegate.setOption(UnixSocketOptions.SO_SNDTIMEO, Math.max(timeout, 0));
148 | if (bufferSize > 0) {
149 | delegate.setOption(UnixSocketOptions.SO_SNDBUF, bufferSize);
150 | }
151 | } catch (Exception e) {
152 | try {
153 | delegate.close();
154 | } catch (IOException __) {
155 | // ignore
156 | }
157 | throw e;
158 | }
159 |
160 |
161 | this.delegate = delegate;
162 | }
163 |
164 | @Override
165 | public void close() throws IOException {
166 | disconnect();
167 | }
168 |
169 | @Override
170 | public String getTransportType() {
171 | return "uds-stream";
172 | }
173 |
174 | @Override
175 | public String toString() {
176 | return "[" + getTransportType() + "] " + address;
177 | }
178 |
179 | @Override
180 | public int getMaxPacketSizeBytes() {
181 | return NonBlockingStatsDClient.DEFAULT_UDS_MAX_PACKET_SIZE_BYTES;
182 | }
183 | }
184 |
--------------------------------------------------------------------------------
/src/main/java/com/timgroup/statsd/Utf8.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2013 The Guava Authors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
5 | * in compliance with the License. You may obtain a copy of the License at
6 | *
7 | * http://www.apache.org/licenses/LICENSE-2.0
8 | *
9 | * Unless required by applicable law or agreed to in writing, software distributed under the License
10 | * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
11 | * or implied. See the License for the specific language governing permissions and limitations under
12 | * the License.
13 | */
14 |
15 | package com.timgroup.statsd;
16 |
17 | import static java.lang.Character.MAX_SURROGATE;
18 | import static java.lang.Character.MIN_SURROGATE;
19 |
20 | import java.nio.charset.StandardCharsets;
21 |
22 | /**
23 | * This class is a partial copy of the {@code com.google.common.base.Utf8}
24 | * class
25 | * from the Guava library.
26 | * It is copied here to avoid a dependency on Guava.
27 | */
28 | final class Utf8 {
29 |
30 | private static final int UTF8_REPLACEMENT_LENGTH = StandardCharsets.UTF_8.newEncoder().replacement().length;
31 |
32 | private Utf8() {
33 | }
34 |
35 | /**
36 | * Returns the number of bytes in the UTF-8-encoded form of {@code sequence}. For a string, this
37 | * method is equivalent to {@code string.getBytes(UTF_8).length}, but is more efficient in both
38 | * time and space.
39 | *
40 | * @throws IllegalArgumentException if {@code sequence} contains ill-formed UTF-16 (unpaired
41 | * surrogates)
42 | */
43 | public static int encodedLength(CharSequence sequence) {
44 | // Warning to maintainers: this implementation is highly optimized.
45 | int utf16Length = sequence.length();
46 | int utf8Length = utf16Length;
47 | int index = 0;
48 |
49 | // This loop optimizes for pure ASCII.
50 | while (index < utf16Length && sequence.charAt(index) < 0x80) {
51 | index++;
52 | }
53 |
54 | // This loop optimizes for chars less than 0x800.
55 | for (; index < utf16Length; index++) {
56 | char character = sequence.charAt(index);
57 | if (character < 0x800) {
58 | utf8Length += ((0x7f - character) >>> 31); // branch free!
59 | } else {
60 | utf8Length += encodedLengthGeneral(sequence, index);
61 | break;
62 | }
63 | }
64 |
65 | if (utf8Length < utf16Length) {
66 | // Necessary and sufficient condition for overflow because of maximum 3x expansion
67 | throw new IllegalArgumentException(
68 | "UTF-8 length does not fit in int: " + (utf8Length + (1L << 32)));
69 | }
70 | return utf8Length;
71 | }
72 |
73 | private static int encodedLengthGeneral(CharSequence sequence, int start) {
74 | int utf16Length = sequence.length();
75 | int utf8Length = 0;
76 | for (int index = start; index < utf16Length; index++) {
77 | char character = sequence.charAt(index);
78 | if (character < 0x800) {
79 | utf8Length += (0x7f - character) >>> 31; // branch free!
80 | } else {
81 | utf8Length += 2;
82 | // jdk7+: if (Character.isSurrogate(character)) {
83 | if (MIN_SURROGATE <= character && character <= MAX_SURROGATE) {
84 | // Check that we have a well-formed surrogate pair.
85 | if (Character.codePointAt(sequence, index) == character) {
86 | // Bad input so deduct char length and account for the replacement characters
87 | utf8Length += -2 + UTF8_REPLACEMENT_LENGTH - 1;
88 | } else {
89 | index++;
90 | }
91 | }
92 | }
93 | }
94 | return utf8Length;
95 | }
96 | }
97 |
--------------------------------------------------------------------------------
/src/main/resources/dogstatsd/version.properties:
--------------------------------------------------------------------------------
1 | dogstatsd_client_version=${project.version}
2 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/BuilderAddressTest.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.net.SocketAddress;
4 | import java.net.InetSocketAddress;
5 |
6 | import java.util.ArrayList;
7 | import java.util.Arrays;
8 | import java.util.Collection;
9 |
10 | import jnr.unixsocket.UnixSocketAddress;
11 |
12 | import org.junit.Before;
13 | import org.junit.Test;
14 | import org.junit.Rule;
15 | import org.junit.contrib.java.lang.system.EnvironmentVariables;
16 |
17 | import org.junit.runner.RunWith;
18 | import org.junit.runners.Parameterized;
19 | import org.junit.runners.Parameterized.Parameters;
20 |
21 | import static org.junit.Assert.assertEquals;
22 |
23 | @RunWith(Parameterized.class)
24 | public class BuilderAddressTest {
25 | @Rule
26 | public final EnvironmentVariables environmentVariables = new EnvironmentVariables();
27 |
28 | final String url;
29 | final String host;
30 | final String port;
31 | final String pipe;
32 | final SocketAddress expected;
33 |
34 | public BuilderAddressTest(String url, String host, String port, String pipe, SocketAddress expected) {
35 | this.url = url;
36 | this.host = host;
37 | this.port = port;
38 | this.pipe = pipe;
39 | this.expected = expected;
40 | }
41 |
42 | static final private int defaultPort = NonBlockingStatsDClient.DEFAULT_DOGSTATSD_PORT;
43 |
44 | @Parameters
45 | public static Collection parameters() {
46 | ArrayList params = new ArrayList();
47 |
48 | params.addAll(Arrays.asList(new Object[][]{
49 | // DD_DOGSTATSD_URL
50 | { "udp://1.1.1.1", null, null, null, new InetSocketAddress("1.1.1.1", defaultPort) },
51 | { "udp://1.1.1.1:9999", null, null, null, new InetSocketAddress("1.1.1.1", 9999) },
52 | { "\\\\.\\pipe\\foo", null, null, null, new NamedPipeSocketAddress("\\\\.\\pipe\\foo") },
53 |
54 | // DD_AGENT_HOST
55 | { null, "1.1.1.1", null, null, new InetSocketAddress("1.1.1.1", defaultPort) },
56 |
57 | // DD_AGENT_HOST, DD_DOGSTATSD_PORT
58 | { null, "1.1.1.1", "9999", null, new InetSocketAddress("1.1.1.1", 9999) },
59 |
60 | { null, null, null, "foo", new NamedPipeSocketAddress("\\\\.\\pipe\\foo") },
61 |
62 | // DD_DOGSTATSD_URL overrides other env vars.
63 | { "udp://1.1.1.1", null, null, "foo", new InetSocketAddress("1.1.1.1", defaultPort) },
64 | { "udp://1.1.1.1:9999", null, null, "foo", new InetSocketAddress("1.1.1.1", 9999) },
65 | { "\\\\.\\pipe\\foo", null, null, "bar", new NamedPipeSocketAddress("\\\\.\\pipe\\foo") },
66 | { "\\\\.\\pipe\\foo", "1.1.1.1", null, null, new NamedPipeSocketAddress("\\\\.\\pipe\\foo") },
67 | { "\\\\.\\pipe\\foo", "1.1.1.1", "9999", null, new NamedPipeSocketAddress("\\\\.\\pipe\\foo") },
68 |
69 | // DD_DOGSTATSD_NAMED_PIPE overrides DD_AGENT_HOST.
70 | { null, "1.1.1.1", null, "foo", new NamedPipeSocketAddress("\\\\.\\pipe\\foo") },
71 | { null, "1.1.1.1", "9999", "foo", new NamedPipeSocketAddress("\\\\.\\pipe\\foo") },
72 | }));
73 |
74 | if (TestHelpers.isJnrAvailable()) {
75 | // Here we use FakeUnixSocketAddress instead of UnixSocketAddress to make sure we can always run the tests without jnr-unixsock.
76 |
77 | UnixSocketAddressWithTransport unixDsd = new UnixSocketAddressWithTransport(new FakeUnixSocketAddress("/dsd.sock"), UnixSocketAddressWithTransport.TransportType.UDS);
78 | UnixSocketAddressWithTransport unixDgramDsd = new UnixSocketAddressWithTransport(new FakeUnixSocketAddress("/dsd.sock"), UnixSocketAddressWithTransport.TransportType.UDS_DATAGRAM);
79 | UnixSocketAddressWithTransport unixStreamDsd = new UnixSocketAddressWithTransport(new FakeUnixSocketAddress("/dsd.sock"), UnixSocketAddressWithTransport.TransportType.UDS_STREAM);
80 |
81 | params.addAll(Arrays.asList(new Object[][]{
82 | { "unix:///dsd.sock", null, null, null, unixDsd },
83 | { "unix://unused/dsd.sock", null, null, null, unixDsd },
84 | { "unix://unused:9999/dsd.sock", null, null, null, unixDsd},
85 | { null, "/dsd.sock", "0", null, unixDsd },
86 | { "unix:///dsd.sock", "1.1.1.1", "9999", null, unixDsd },
87 | { "unixgram:///dsd.sock", null, null, null, unixDgramDsd },
88 | { "unixstream:///dsd.sock", null, null, null, unixStreamDsd },
89 | }));
90 | }
91 |
92 | return params;
93 | }
94 |
95 | static class FakeUnixSocketAddress extends SocketAddress {
96 | final String path;
97 | public FakeUnixSocketAddress(String path) {
98 | this.path = path;
99 | }
100 |
101 | public String getPath() {
102 | return path;
103 | }
104 | }
105 |
106 | @Before
107 | public void set() {
108 | set(NonBlockingStatsDClient.DD_DOGSTATSD_URL_ENV_VAR, url);
109 | set(NonBlockingStatsDClient.DD_AGENT_HOST_ENV_VAR, host);
110 | set(NonBlockingStatsDClient.DD_DOGSTATSD_PORT_ENV_VAR, port);
111 | set(NonBlockingStatsDClient.DD_NAMED_PIPE_ENV_VAR, pipe);
112 | }
113 |
114 | void set(String name, String val) {
115 | if (val != null) {
116 | environmentVariables.set(name, val);
117 | } else {
118 | environmentVariables.clear(name);
119 | }
120 | }
121 |
122 | @Test(timeout = 5000L)
123 | public void address_resolution() throws Exception {
124 | NonBlockingStatsDClientBuilder b;
125 |
126 | // Default configuration matches env vars
127 | b = new NonBlockingStatsDClientBuilder().resolve();
128 | SocketAddress actual = b.addressLookup.call();
129 |
130 | // Make it possible to run this code even if we don't have jnr-unixsocket.
131 | if (expected instanceof UnixSocketAddressWithTransport) {
132 | UnixSocketAddressWithTransport a = (UnixSocketAddressWithTransport)actual;
133 | UnixSocketAddressWithTransport e = (UnixSocketAddressWithTransport)expected;
134 | assertEquals(((FakeUnixSocketAddress)e.getAddress()).getPath(), ((UnixSocketAddress)a.getAddress()).path());
135 | assertEquals(e.getTransportType(), a.getTransportType());
136 | } else {
137 | assertEquals(expected, actual);
138 | }
139 |
140 | // Explicit configuration is used regardless of environment variables.
141 | b = new NonBlockingStatsDClientBuilder().hostname("2.2.2.2").resolve();
142 | assertEquals(new InetSocketAddress("2.2.2.2", defaultPort), b.addressLookup.call());
143 |
144 | b = new NonBlockingStatsDClientBuilder().hostname("2.2.2.2").port(2222).resolve();
145 | assertEquals(new InetSocketAddress("2.2.2.2", 2222), b.addressLookup.call());
146 |
147 | b = new NonBlockingStatsDClientBuilder().namedPipe("ook").resolve();
148 | assertEquals(new NamedPipeSocketAddress("ook"), b.addressLookup.call());
149 | }
150 | }
151 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/DummyLowMemStatsDServer.java:
--------------------------------------------------------------------------------
1 |
2 | package com.timgroup.statsd;
3 |
4 | import java.io.IOException;
5 | import java.util.concurrent.atomic.AtomicInteger;
6 |
7 |
8 | class DummyLowMemStatsDServer extends UDPDummyStatsDServer {
9 | private final AtomicInteger messageCount = new AtomicInteger(0);
10 |
11 | public DummyLowMemStatsDServer(int port) throws IOException {
12 | super(port);
13 | }
14 |
15 | @Override
16 | public void clear() {
17 | messageCount.set(0);
18 | super.clear();
19 | }
20 |
21 | public int getMessageCount() {
22 | return messageCount.get();
23 | }
24 |
25 | @Override
26 | protected void addMessage(String msg) {
27 | messageCount.incrementAndGet();
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/DummyStatsDServer.java:
--------------------------------------------------------------------------------
1 |
2 | package com.timgroup.statsd;
3 |
4 | import java.io.Closeable;
5 | import java.io.IOException;
6 | import java.nio.Buffer;
7 | import java.nio.ByteBuffer;
8 | import java.nio.charset.StandardCharsets;
9 | import java.util.ArrayList;
10 | import java.util.List;
11 | import java.util.concurrent.atomic.AtomicInteger;
12 |
13 | import static com.timgroup.statsd.NonBlockingStatsDClient.DEFAULT_UDS_MAX_PACKET_SIZE_BYTES;
14 |
15 | abstract class DummyStatsDServer implements Closeable {
16 | private final List messagesReceived = new ArrayList();
17 | private AtomicInteger packetsReceived = new AtomicInteger(0);
18 |
19 | protected volatile Boolean freeze = false;
20 | Thread thread;
21 |
22 | protected void listen() {
23 | thread = new Thread(new Runnable() {
24 | @Override
25 | public void run() {
26 | final ByteBuffer packet = ByteBuffer.allocate(DEFAULT_UDS_MAX_PACKET_SIZE_BYTES);
27 |
28 | while(isOpen() && !Thread.interrupted()) {
29 | if (freeze) {
30 | try {
31 | Thread.sleep(10);
32 | } catch (InterruptedException e) {
33 | }
34 | } else {
35 | try {
36 | ((Buffer)packet).clear(); // Cast necessary to handle Java9 covariant return types
37 | // see: https://jira.mongodb.org/browse/JAVA-2559 for ref.
38 | receive(packet);
39 | handlePacket(packet);
40 | } catch (IOException e) {
41 | }
42 | }
43 | }
44 | }
45 | });
46 | thread.setDaemon(true);
47 | thread.start();
48 | }
49 |
50 | protected boolean sleepIfFrozen() {
51 | if (freeze) {
52 | try {
53 | Thread.sleep(10);
54 | } catch (InterruptedException e) {
55 | }
56 | }
57 | return freeze;
58 | }
59 |
60 | protected void handlePacket(ByteBuffer packet) {
61 | packetsReceived.addAndGet(1);
62 |
63 | packet.flip();
64 | for (String msg : StandardCharsets.UTF_8.decode(packet).toString().split("\n")) {
65 | addMessage(msg);
66 | }
67 | }
68 |
69 | public void waitForMessage() {
70 | waitForMessage(null);
71 | }
72 |
73 | public void waitForMessage(String prefix) {
74 | boolean done = false;
75 |
76 | while (!done) {
77 | try {
78 | synchronized(messagesReceived) {
79 | done = !messagesReceived.isEmpty();
80 | }
81 |
82 | if (done && prefix != null && !prefix.isEmpty()) {
83 | done = false;
84 | List messages = this.messagesReceived();
85 | for (String message : messages) {
86 | if(message.contains(prefix)) {
87 | return;
88 | }
89 | }
90 | }
91 | Thread.sleep(100L);
92 | } catch (InterruptedException e) {
93 | }
94 | }
95 | }
96 |
97 | public List messagesReceived() {
98 | synchronized(messagesReceived) {
99 | return new ArrayList(messagesReceived);
100 | }
101 | }
102 |
103 | public int getPacketsReceived() {
104 | return packetsReceived.get();
105 | }
106 |
107 | public void freeze() {
108 | freeze = true;
109 | }
110 |
111 | public void unfreeze() {
112 | freeze = false;
113 | }
114 |
115 | public void clear() {
116 | packetsReceived.set(0);
117 | messagesReceived.clear();
118 | }
119 |
120 | protected abstract boolean isOpen();
121 |
122 | protected abstract void receive(ByteBuffer packet) throws IOException;
123 |
124 | protected void addMessage(String msg) {
125 | synchronized(messagesReceived) {
126 | String trimmed = msg.trim();
127 | if (!trimmed.isEmpty()) {
128 | messagesReceived.add(msg.trim());
129 | }
130 | }
131 | }
132 |
133 | }
134 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/EventTest.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import org.junit.Test;
4 |
5 | import java.util.Date;
6 |
7 | import static org.junit.Assert.assertEquals;
8 |
9 | public class EventTest {
10 | @Test
11 | public void builds() {
12 | final Event event = Event.builder()
13 | .withTitle("title1")
14 | .withText("text1")
15 | .withDate(1234)
16 | .withHostname("host1")
17 | .withPriority(Event.Priority.LOW)
18 | .withAggregationKey("key1")
19 | .withAlertType(Event.AlertType.ERROR)
20 | .withSourceTypeName("sourceType1")
21 | .build();
22 |
23 | assertEquals("title1", event.getTitle());
24 | assertEquals("text1", event.getText());
25 | assertEquals(1234, event.getMillisSinceEpoch());
26 | assertEquals("host1", event.getHostname());
27 | assertEquals("low", event.getPriority());
28 | assertEquals("key1", event.getAggregationKey());
29 | assertEquals("error", event.getAlertType());
30 | assertEquals("sourceType1", event.getSourceTypeName());
31 | }
32 |
33 | @Test
34 | public void builds_with_defaults() {
35 | final Event event = Event.builder()
36 | .withTitle("title1")
37 | .withText("text1")
38 | .build();
39 |
40 | assertEquals("title1", event.getTitle());
41 | assertEquals("text1", event.getText());
42 | assertEquals(-1, event.getMillisSinceEpoch());
43 | assertEquals(null, event.getHostname());
44 | assertEquals(null, event.getPriority());
45 | assertEquals(null, event.getAggregationKey());
46 | assertEquals(null, event.getAlertType());
47 | assertEquals(null, event.getSourceTypeName());
48 | }
49 |
50 | @Test (expected = IllegalStateException.class)
51 | public void fails_without_title() {
52 | Event.builder().withText("text1")
53 | .withDate(1234)
54 | .withHostname("host1")
55 | .withPriority(Event.Priority.LOW)
56 | .withAggregationKey("key1")
57 | .withAlertType(Event.AlertType.ERROR)
58 | .withSourceTypeName("sourceType1")
59 | .build();
60 | }
61 |
62 | @Test
63 | public void builds_with_date() {
64 | final long expectedMillis = 1234567000;
65 | final Date date = new Date(expectedMillis);
66 | final Event event = Event.builder()
67 | .withTitle("title1")
68 | .withText("text1")
69 | .withDate(date)
70 | .build();
71 |
72 | assertEquals("title1", event.getTitle());
73 | assertEquals("text1", event.getText());
74 | assertEquals(expectedMillis, event.getMillisSinceEpoch());
75 | }
76 |
77 | @Test
78 | public void builds_without_text() {
79 | final long expectedMillis = 1234567000;
80 | final Date date = new Date(expectedMillis);
81 | final Event event = Event.builder()
82 | .withTitle("title1")
83 | .withDate(date)
84 | .build();
85 |
86 | assertEquals("title1", event.getTitle());
87 | assertEquals(null, event.getText());
88 | assertEquals(expectedMillis, event.getMillisSinceEpoch());
89 | }
90 |
91 | }
92 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/NamedPipeDummyStatsDServer.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import com.sun.jna.platform.win32.Kernel32;
4 | import com.sun.jna.platform.win32.WinBase;
5 | import com.sun.jna.platform.win32.WinError;
6 | import com.sun.jna.platform.win32.WinNT.HANDLE;
7 | import com.sun.jna.ptr.IntByReference;
8 | import java.io.IOException;
9 | import java.nio.ByteBuffer;
10 | import java.util.logging.Logger;
11 |
12 | // Template from https://github.com/java-native-access/jna/blob/master/contrib/platform/test/com/sun/jna/platform/win32/Kernel32NamedPipeTest.java
13 | // And https://docs.microsoft.com/en-us/windows/win32/ipc/multithreaded-pipe-server
14 | public class NamedPipeDummyStatsDServer extends DummyStatsDServer {
15 | private static final Logger log = Logger.getLogger("NamedPipeDummyStatsDServer");
16 | private final HANDLE hNamedPipe;
17 | private volatile boolean clientConnected = false;
18 | private volatile boolean isOpen = true;
19 |
20 | public NamedPipeDummyStatsDServer(String pipeName) {
21 | String normalizedPipeName = NamedPipeSocketAddress.normalizePipeName(pipeName);
22 |
23 | hNamedPipe= Kernel32.INSTANCE.CreateNamedPipe(normalizedPipeName,
24 | WinBase.PIPE_ACCESS_DUPLEX, // dwOpenMode
25 | WinBase.PIPE_TYPE_BYTE | WinBase.PIPE_READMODE_BYTE | WinBase.PIPE_WAIT, // dwPipeMode
26 | 1, // nMaxInstances,
27 | Byte.MAX_VALUE, // nOutBufferSize,
28 | Byte.MAX_VALUE, // nInBufferSize,
29 | 1000, // nDefaultTimeOut,
30 | null); // lpSecurityAttributes
31 |
32 | if (WinBase.INVALID_HANDLE_VALUE.equals(hNamedPipe)) {
33 | throw new RuntimeException("Unable to create named pipe");
34 | }
35 |
36 | listen();
37 | }
38 | @Override
39 | protected boolean isOpen() {
40 | return isOpen;
41 | }
42 |
43 | @Override
44 | protected void receive(ByteBuffer packet) throws IOException {
45 | if (!isOpen) {
46 | throw new IOException("Server closed");
47 | }
48 | if (!clientConnected) {
49 | boolean connected = Kernel32.INSTANCE.ConnectNamedPipe(hNamedPipe, null);
50 | // ERROR_PIPE_CONNECTED means the client connected before the server
51 | // The connection is established
52 | int lastError = Kernel32.INSTANCE.GetLastError();
53 | connected = connected || lastError == WinError.ERROR_PIPE_CONNECTED;
54 | if (connected) {
55 | clientConnected = true;
56 | } else {
57 | log.info("Failed to connect. Last error: " + lastError);
58 | close();
59 | return;
60 | }
61 | }
62 |
63 | IntByReference bytesRead = new IntByReference();
64 | boolean success = Kernel32.INSTANCE.ReadFile(
65 | hNamedPipe, // handle to pipe
66 | packet.array(), // buffer to receive data
67 | packet.remaining(), // size of buffer
68 | bytesRead, // number of bytes read
69 | null); // not overlapped I/O
70 |
71 | log.info("Read bytes. Result: " + success + ". Bytes read: " + bytesRead.getValue());
72 | packet.position(bytesRead.getValue());
73 | }
74 |
75 | @Override
76 | public void close() throws IOException {
77 | isOpen = false;
78 | Kernel32.INSTANCE.CloseHandle(hNamedPipe);
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/NamedPipeTest.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import static org.hamcrest.MatcherAssert.assertThat;
4 | import static org.hamcrest.Matchers.contains;
5 | import static org.hamcrest.Matchers.nullValue;
6 | import static org.hamcrest.Matchers.instanceOf;
7 |
8 |
9 | import java.io.IOException;
10 | import java.net.InetSocketAddress;
11 | import java.util.Random;
12 | import java.util.logging.Logger;
13 |
14 | import org.junit.After;
15 | import org.junit.Assume;
16 | import org.junit.Before;
17 | import org.junit.BeforeClass;
18 | import org.junit.Test;
19 | import org.junit.Rule;
20 | import org.junit.contrib.java.lang.system.EnvironmentVariables;
21 | import static org.junit.Assert.assertEquals;
22 |
23 | public class NamedPipeTest implements StatsDClientErrorHandler {
24 | private static final Logger log = Logger.getLogger("NamedPipeTest");
25 |
26 | private static final Random random = new Random();
27 | private NonBlockingStatsDClient client;
28 | private DummyStatsDServer server;
29 | private volatile Exception lastException = new Exception();
30 |
31 | @Rule
32 | public final EnvironmentVariables environmentVariables = new EnvironmentVariables();
33 |
34 | public synchronized void handle(Exception exception) {
35 | log.info("Got exception: " + exception.getMessage());
36 | lastException = exception;
37 | }
38 |
39 | @BeforeClass
40 | public static void supportedOnly() {
41 | Assume.assumeTrue(System.getProperty("os.name").toLowerCase().contains("windows"));
42 | }
43 |
44 | @Before
45 | public void start() {
46 | String pipeName = "testPipe-" + random.nextInt(10000);
47 |
48 | server = new NamedPipeDummyStatsDServer(pipeName);
49 | client = new NonBlockingStatsDClientBuilder().prefix("my.prefix")
50 | .namedPipe(pipeName)
51 | .queueSize(1)
52 | .enableAggregation(false)
53 | .errorHandler(this)
54 | .build();
55 | }
56 |
57 | @After
58 | public void stop() throws IOException {
59 | if (client != null) {
60 | client.stop();
61 | }
62 | if (server != null) {
63 | server.close();
64 | }
65 | }
66 |
67 | @Test(timeout = 5000L)
68 | public void sends_to_statsd() {
69 | for(long i = 0; i < 5 ; i++) {
70 | client.gauge("mycount", i);
71 | server.waitForMessage();
72 | String expected = String.format("my.prefix.mycount:%d|g", i);
73 | assertThat(server.messagesReceived(), contains(expected));
74 | server.clear();
75 | }
76 | assertThat(lastException.getMessage(), nullValue());
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/NonBlockingDirectStatsDClientTest.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import org.junit.After;
4 | import org.junit.AfterClass;
5 | import org.junit.BeforeClass;
6 | import org.junit.FixMethodOrder;
7 | import org.junit.Rule;
8 | import org.junit.Test;
9 | import org.junit.contrib.java.lang.system.EnvironmentVariables;
10 | import org.junit.runners.MethodSorters;
11 |
12 | import java.io.IOException;
13 |
14 | import static org.hamcrest.MatcherAssert.assertThat;
15 | import static org.hamcrest.Matchers.comparesEqualTo;
16 | import static org.hamcrest.Matchers.hasItem;
17 |
18 | @FixMethodOrder(MethodSorters.NAME_ASCENDING)
19 | public class NonBlockingDirectStatsDClientTest {
20 |
21 | private static final int STATSD_SERVER_PORT = 17256;
22 | private static final int MAX_PACKET_SIZE = 64;
23 | private static DirectStatsDClient client;
24 | private static DummyStatsDServer server;
25 |
26 | @Rule
27 | public final EnvironmentVariables environmentVariables = new EnvironmentVariables();
28 |
29 | @BeforeClass
30 | public static void start() throws IOException {
31 | server = new UDPDummyStatsDServer(STATSD_SERVER_PORT);
32 | client = new NonBlockingStatsDClientBuilder()
33 | .prefix("my.prefix")
34 | .hostname("localhost")
35 | .port(STATSD_SERVER_PORT)
36 | .enableTelemetry(false)
37 | .originDetectionEnabled(false)
38 | .maxPacketSizeBytes(MAX_PACKET_SIZE)
39 | .buildDirectStatsDClient();
40 | }
41 |
42 | @AfterClass
43 | public static void stop() {
44 | try {
45 | client.stop();
46 | server.close();
47 | } catch (java.io.IOException ignored) {
48 | }
49 | }
50 |
51 | @After
52 | public void clear() {
53 | server.clear();
54 | }
55 |
56 |
57 | @Test(timeout = 5000L)
58 | public void sends_multivalued_distribution_to_statsd() {
59 | client.recordDistributionValues("mydistribution", new long[] { 423L, 234L }, Double.NaN);
60 | server.waitForMessage("my.prefix");
61 |
62 | assertThat(server.messagesReceived(), hasItem(comparesEqualTo("my.prefix.mydistribution:423:234|d")));
63 | }
64 |
65 | @Test(timeout = 5000L)
66 | public void sends_double_multivalued_distribution_to_statsd() {
67 | client.recordDistributionValues("mydistribution", new double[] { 0.423D, 0.234D }, Double.NaN);
68 | server.waitForMessage("my.prefix");
69 |
70 | assertThat(server.messagesReceived(), hasItem(comparesEqualTo("my.prefix.mydistribution:0.423:0.234|d")));
71 | }
72 |
73 | @Test(timeout = 5000L)
74 | public void sends_multivalued_distribution_to_statsd_with_tags() {
75 | client.recordDistributionValues("mydistribution", new long[] { 423L, 234L }, Double.NaN, "foo:bar", "baz");
76 | server.waitForMessage("my.prefix");
77 |
78 | assertThat(server.messagesReceived(), hasItem(comparesEqualTo("my.prefix.mydistribution:423:234|d|#baz,foo:bar")));
79 | }
80 |
81 | @Test(timeout = 5000L)
82 | public void sends_multivalued_distribution_to_statsd_with_sampling_rate() {
83 | client.recordDistributionValues("mydistribution", new long[] { 423L, 234L }, 1);
84 | server.waitForMessage("my.prefix");
85 |
86 | assertThat(server.messagesReceived(), hasItem(comparesEqualTo("my.prefix.mydistribution:423:234|d|@1.000000")));
87 | }
88 |
89 | @Test(timeout = 5000L)
90 | public void sends_multivalued_distribution_to_statsd_with_non_1_sampling_rate() {
91 | client.recordDistributionValues("mydistribution", new long[] { 423L, 234L }, 0.1);
92 | server.waitForMessage("my.prefix");
93 |
94 | assertThat(server.messagesReceived(), hasItem(comparesEqualTo("my.prefix.mydistribution:423:234|d|@0.100000")));
95 | }
96 |
97 | @Test(timeout = 5000L)
98 | public void sends_multivalued_distribution_to_statsd_with_tags_and_sampling_rate() {
99 | client.recordDistributionValues("mydistribution", new long[] { 423L, 234L }, 1, "foo:bar", "baz");
100 | server.waitForMessage("my.prefix");
101 |
102 | assertThat(server.messagesReceived(), hasItem(comparesEqualTo("my.prefix.mydistribution:423:234|d|@1.000000|#baz,foo:bar")));
103 | }
104 |
105 | @Test(timeout = 5000L)
106 | public void sends_too_long_multivalued_distribution_to_statsd() {
107 | long[] values = {423L, 234L, 456L, 512L, 345L, 898L, 959876543123L, 667L};
108 | client.recordDistributionValues("mydistribution", values, 0.4, "foo:bar", "baz");
109 |
110 | server.waitForMessage("my.prefix");
111 | assertThat(server.messagesReceived(), hasItem(comparesEqualTo("my.prefix.mydistribution:423:234:456|d|@0.400000|#baz,foo:bar")));
112 |
113 | server.waitForMessage("my.prefix");
114 | assertThat(server.messagesReceived(), hasItem(comparesEqualTo("my.prefix.mydistribution:512:345:898|d|@0.400000|#baz,foo:bar")));
115 |
116 | server.waitForMessage("my.prefix");
117 | assertThat(server.messagesReceived(), hasItem(comparesEqualTo("my.prefix.mydistribution:959876543123|d|@0.400000|#baz,foo:bar")));
118 |
119 | server.waitForMessage("my.prefix");
120 | assertThat(server.messagesReceived(), hasItem(comparesEqualTo("my.prefix.mydistribution:667|d|@0.400000|#baz,foo:bar")));
121 | }
122 |
123 | }
124 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/NonBlockingStatsDClientMaxPerfTest.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.io.IOException;
4 | import java.net.SocketException;
5 |
6 | import java.util.Arrays;
7 | import java.util.Collection;
8 | import java.util.Random;
9 | import java.util.logging.Logger;
10 | import java.util.concurrent.ExecutorService;
11 | import java.util.concurrent.Executors;
12 | import java.util.concurrent.TimeUnit;
13 | import java.util.concurrent.atomic.AtomicBoolean;
14 |
15 | import org.junit.After;
16 | import org.junit.Assume;
17 | import org.junit.Before;
18 | import org.junit.Test;
19 | import org.junit.runner.RunWith;
20 | import org.junit.runners.Parameterized;
21 | import org.junit.runners.Parameterized.Parameters;
22 |
23 | import static org.junit.Assert.assertNotEquals;
24 |
25 | @RunWith(Parameterized.class)
26 | public final class NonBlockingStatsDClientMaxPerfTest {
27 |
28 | private static final int testWorkers = 4;
29 | private static final int port = 17255;
30 | private final int processorWorkers;
31 | private final int senderWorkers;
32 | private final int duration; // Duration in secs
33 | private final int qSize; // Queue length (number of elements)
34 |
35 | private NonBlockingStatsDClient client;
36 | private DummyLowMemStatsDServer server;
37 |
38 | private AtomicBoolean running;
39 | private final ExecutorService executor;
40 |
41 | private static Logger log = Logger.getLogger("NonBlockingStatsDClientMaxPerfTest");
42 |
43 | @Parameters
44 | public static Collection data() {
45 | return Arrays.asList(new Object[][] {
46 | { 30, false, 256, 1, 1 }, // 30 seconds, non-blocking, 256 qSize, 1 worker
47 | { 30, false, 512, 1, 1 }, // 30 seconds, non-blocking, 512 qSize, 1 worker
48 | { 30, false, 1024, 1, 1 }, // 30 seconds, non-blocking, 1024 qSize, 1 worker
49 | { 30, false, 2048, 1, 1 }, // 30 seconds, non-blocking, 2048 qSize, 1 worker
50 | { 30, false, 4096, 1, 1 }, // 30 seconds, non-blocking, 4096 qSize, 1 worker
51 | // { 30, 17260, Integer.MAX_VALUE, 1 }, // 30 seconds, non-blocking, MAX_VALUE qSize, 1 worker
52 | { 30, false, 256, 2, 1 }, // 30 seconds, non-blocking, 256 qSize, 2 workers
53 | { 30, false, 512, 2, 1 }, // 30 seconds, non-blocking, 512 qSize, 2 workers
54 | { 30, false, 1024, 2, 1 }, // 30 seconds, non-blocking, 1024 qSize, 2 workers
55 | { 30, false, 2048, 2, 1 }, // 30 seconds, non-blocking, 2048 qSize, 2 workers
56 | { 30, false, 4096, 2, 1 }, // 30 seconds, non-blocking, 4096 qSize, 2 workers
57 | // // { 30, false, Integer.MAX_VALUE, 2 } // 30 seconds, non-blocking, MAX_VALUE qSize, 2 workers
58 | { 30, false, 256, 1, 2}, // 30 seconds, non-blocking, 256 qSize, 1 sender worker, 2 processor workers
59 | { 30, false, 512, 1, 2 }, // 30 seconds, non-blocking, 512 qSize, 1 sender worker, 2 processor workers
60 | { 30, false, 1024, 1, 2 }, // 30 seconds, non-blocking, 1024 qSize, 1 sender worker, 2 processor workers
61 | { 30, false, 2048, 1, 2 }, // 30 seconds, non-blocking, 2048 qSize, 1 sender worke, 2 processor workers
62 | { 30, false, 4096, 1, 2 }, // 30 seconds, non-blocking, 4096 qSize, 1 sender worke, 2 processor workers
63 | // // { 30, false, Integer.MAX_VALUE, 1, 2 }, // 30 seconds, non-blocking, MAX_VALUE qSize, 1 worker
64 | { 30, false, 256, 2, 2 }, // 30 seconds, non-blocking, 256 qSize, 2 sender workers, 2 processor workers
65 | { 30, false, 512, 2, 2 }, // 30 seconds, non-blocking, 512 qSize, 2 sender workers, 2 processor workers
66 | { 30, false, 1024, 2, 2 }, // 30 seconds, non-blocking, 1024 qSize, 2 sender workers, 2 processor workers
67 | { 30, false, 2048, 2, 2 }, // 30 seconds, non-blocking, 2048 qSize, 2 sender workers, 2 processor workers
68 | { 30, false, 4096, 2, 2 }, // 30 seconds, non-blocking, 4096 qSize, 2 sender workers, 2 processor workers
69 | // // { 30, false, Integer.MAX_VALUE, 2 } // 30 seconds, non-blocking, MAX_VALUE qSize, 2 sender workers
70 | { 30, true, 256, 1, 1 }, // 30 seconds, non-blocking, 256 qSize, 1 worker
71 | { 30, true, 512, 1, 1 }, // 30 seconds, non-blocking, 512 qSize, 1 worker
72 | { 30, true, 1024, 1, 1 }, // 30 seconds, non-blocking, 1024 qSize, 1 worker
73 | { 30, true, 2048, 1, 1 }, // 30 seconds, non-blocking, 2048 qSize, 1 worker
74 | { 30, true, 4096, 1, 1 }, // 30 seconds, non-blocking, 4096 qSize, 1 worker
75 | // { 30, 17260, Integer.MAX_VALUE, 1 }, // 30 seconds, non-blocking, MAX_VALUE qSize, 1 worker
76 | { 30, true, 256, 2, 1 }, // 30 seconds, non-blocking, 256 qSize, 2 workers
77 | { 30, true, 512, 2, 1 }, // 30 seconds, non-blocking, 512 qSize, 2 workers
78 | { 30, true, 1024, 2, 1 }, // 30 seconds, non-blocking, 1024 qSize, 2 workers
79 | { 30, true, 2048, 2, 1 }, // 30 seconds, non-blocking, 2048 qSize, 2 workers
80 | { 30, true, 4096, 2, 1 }, // 30 seconds, non-blocking, 4096 qSize, 2 workers
81 | // // { 30, true, Integer.MAX_VALUE, 2 } // 30 seconds, non-blocking, MAX_VALUE qSize, 2 workers
82 | { 30, true, 256, 1, 2}, // 30 seconds, non-blocking, 256 qSize, 1 sender worker, 2 processor workers
83 | { 30, true, 512, 1, 2 }, // 30 seconds, non-blocking, 512 qSize, 1 sender worker, 2 processor workers
84 | { 30, true, 1024, 1, 2 }, // 30 seconds, non-blocking, 1024 qSize, 1 sender worker, 2 processor workers
85 | { 30, true, 2048, 1, 2 }, // 30 seconds, non-blocking, 2048 qSize, 1 sender worke, 2 processor workers
86 | { 30, true, 4096, 1, 2 }, // 30 seconds, non-blocking, 4096 qSize, 1 sender worke, 2 processor workers
87 | // // { 30, true, Integer.MAX_VALUE, 1, 2 }, // 30 seconds, non-blocking, MAX_VALUE qSize, 1 worker
88 | { 30, true, 256, 2, 2 }, // 30 seconds, non-blocking, 256 qSize, 2 sender workers, 2 processor workers
89 | { 30, true, 512, 2, 2 }, // 30 seconds, non-blocking, 512 qSize, 2 sender workers, 2 processor workers
90 | { 30, true, 1024, 2, 2 }, // 30 seconds, non-blocking, 1024 qSize, 2 sender workers, 2 processor workers
91 | { 30, true, 2048, 2, 2 }, // 30 seconds, non-blocking, 2048 qSize, 2 sender workers, 2 processor workers
92 | { 30, true, 4096, 2, 2 }, // 30 seconds, non-blocking, 4096 qSize, 2 sender workers, 2 processor workers
93 | // // { 30, true, Integer.MAX_VALUE, 2 } // 30 seconds, non-blocking, MAX_VALUE qSize, 2 sender workers
94 | });
95 | }
96 |
97 | public NonBlockingStatsDClientMaxPerfTest(int duration, boolean blocking, int qSize,
98 | int processorWorkers, int senderWorkers) throws IOException {
99 | this.duration = duration;
100 | this.qSize = qSize;
101 | this.processorWorkers = processorWorkers;
102 | this.senderWorkers = senderWorkers;
103 | this.client = new NonBlockingStatsDClientBuilder().prefix("my.prefix")
104 | .hostname("localhost")
105 | .port(port)
106 | .blocking(blocking)
107 | .queueSize(qSize)
108 | .senderWorkers(senderWorkers)
109 | .processorWorkers(processorWorkers)
110 | .enableAggregation(false)
111 | .build();
112 | this.server = new DummyLowMemStatsDServer(port);
113 |
114 | this.executor = Executors.newFixedThreadPool(senderWorkers);
115 | this.running = new AtomicBoolean(true);
116 |
117 | }
118 |
119 | /**
120 | * Run with -Dtest_perf=true if you wish the performance tests defined here to run
121 | */
122 | @Before
123 | public void shouldRun() {
124 | boolean run = false;
125 | try {
126 | run = (System.getProperty("test_perf").compareToIgnoreCase("true") == 0);
127 | } catch (Exception ex) {
128 | // NADA
129 | }
130 | Assume.assumeTrue(run);
131 | }
132 |
133 | @After
134 | public void stop() throws Exception {
135 | client.stop();
136 | server.close();
137 | }
138 |
139 | @Test
140 | public void perfTest() throws Exception {
141 |
142 | for(int i=0 ; i < this.testWorkers ; i++) {
143 | executor.submit(new Runnable() {
144 | public void run() {
145 | while (running.get()) {
146 | client.count("mycount", 1);
147 | }
148 | }
149 | });
150 | }
151 |
152 | Thread.sleep(TimeUnit.SECONDS.toMillis(this.duration));
153 | running.set(false);
154 |
155 | executor.shutdown();
156 | executor.awaitTermination(1, TimeUnit.SECONDS);
157 |
158 | assertNotEquals(0, server.getMessageCount());
159 | log.info("Messages at server: " + server.getMessageCount() + " packets: " + server.getPacketsReceived());
160 | }
161 | }
162 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/NonBlockingStatsDClientPerfTest.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 |
4 | import java.io.IOException;
5 | import java.net.SocketException;
6 | import java.util.concurrent.ExecutorService;
7 | import java.util.concurrent.Executors;
8 | import java.util.concurrent.TimeUnit;
9 | import java.util.logging.Logger;
10 | import java.util.Random;
11 | import org.junit.After;
12 | import org.junit.AfterClass;
13 | import org.junit.Before;
14 | import org.junit.BeforeClass;
15 | import org.junit.Test;
16 |
17 | import static org.junit.Assert.assertEquals;
18 |
19 | public final class NonBlockingStatsDClientPerfTest {
20 |
21 |
22 | private static final int STATSD_SERVER_PORT = 17255;
23 | private static final Random RAND = new Random();
24 | private static final NonBlockingStatsDClient client = new NonBlockingStatsDClientBuilder().prefix("my.prefix")
25 | .hostname("localhost")
26 | .port(STATSD_SERVER_PORT)
27 | .blocking(true) // non-blocking processors will drop messages if the queue fills up
28 | .enableTelemetry(false)
29 | .enableAggregation(false)
30 | .originDetectionEnabled(false)
31 | .build();
32 |
33 | private static final NonBlockingStatsDClient clientAggr = new NonBlockingStatsDClientBuilder().prefix("my.prefix.aggregated")
34 | .hostname("localhost")
35 | .port(STATSD_SERVER_PORT)
36 | .blocking(true) // non-blocking processors will drop messages if the queue fills up
37 | .enableTelemetry(false)
38 | .originDetectionEnabled(false)
39 | .build();
40 |
41 | private ExecutorService executor;
42 | private static DummyStatsDServer server;
43 |
44 | private static Logger log = Logger.getLogger("NonBlockingStatsDClientPerfTest");
45 |
46 | @BeforeClass
47 | public static void start() throws IOException {
48 | server = new UDPDummyStatsDServer(STATSD_SERVER_PORT);
49 | }
50 |
51 | @AfterClass
52 | public static void stop() throws Exception {
53 |
54 | client.stop();
55 | clientAggr.stop();
56 | server.close();
57 | }
58 |
59 | @Before
60 | public void setup() throws Exception {
61 | executor = Executors.newFixedThreadPool(10);
62 | }
63 |
64 | @After
65 | public void clear() throws Exception {
66 | executor.shutdown();
67 | executor.awaitTermination(20, TimeUnit.SECONDS);
68 | server.clear();
69 | }
70 |
71 | @Test(timeout=30000)
72 | public void perfTest() throws Exception {
73 |
74 | int testSize = 10000;
75 | for(int i = 0; i < testSize; ++i) {
76 | executor.submit(new Runnable() {
77 | public void run() {
78 | client.count("mycount", 1);
79 | }
80 | });
81 |
82 | }
83 |
84 | while(server.messagesReceived().size() < testSize) {
85 | try {
86 | Thread.sleep(50);
87 | } catch (InterruptedException ex) {}
88 | }
89 |
90 | assertEquals(testSize, server.messagesReceived().size());
91 | }
92 |
93 | @Test(timeout=30000)
94 | public void perfAggregatedTest() throws Exception {
95 |
96 | int expectedSize = 1;
97 | long start = System.currentTimeMillis();
98 |
99 | while(System.currentTimeMillis() - start < clientAggr.statsDProcessor.getAggregator().getFlushInterval() - 1) {
100 | clientAggr.count("myaggrcount", 1);
101 | Thread.sleep(50);
102 | }
103 |
104 | while(server.messagesReceived().size() < expectedSize) {
105 | try {
106 | Thread.sleep(50);
107 | } catch (InterruptedException ex) {}
108 | }
109 |
110 | assertEquals(expectedSize, server.messagesReceived().size());
111 | }
112 | }
113 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/RecordingErrorHandler.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.util.ArrayList;
4 | import java.util.concurrent.ConcurrentLinkedQueue;
5 | import java.util.List;
6 | import java.util.Queue;
7 |
8 |
9 | /**
10 | * @author Taylor Schilling
11 | */
12 | public class RecordingErrorHandler implements StatsDClientErrorHandler {
13 | private final Queue exceptions = new ConcurrentLinkedQueue<>();
14 |
15 | @Override
16 | public void handle(final Exception exception) {
17 | exceptions.add(exception);
18 | }
19 |
20 | public List getExceptions() {
21 | return new ArrayList(exceptions);
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/StatsDAggregatorTest.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import org.junit.After;
4 | import org.junit.AfterClass;
5 | import org.junit.Assume;
6 | import org.junit.BeforeClass;
7 | import org.junit.FixMethodOrder;
8 | import org.junit.Rule;
9 | import org.junit.Test;
10 | import org.junit.contrib.java.lang.system.EnvironmentVariables;
11 | import org.junit.runners.MethodSorters;
12 |
13 | import java.util.Iterator;
14 | import java.util.Map;
15 | import java.util.Queue;
16 | import java.util.concurrent.ConcurrentLinkedQueue;
17 | import java.util.concurrent.ExecutorService;
18 | import java.util.concurrent.Executors;
19 | import java.util.concurrent.ThreadFactory;
20 | import java.util.concurrent.atomic.AtomicInteger;
21 | import java.util.logging.Logger;
22 |
23 | import static org.junit.Assert.assertEquals;
24 | import static org.junit.Assert.assertTrue;
25 |
26 | @FixMethodOrder(MethodSorters.NAME_ASCENDING)
27 | public class StatsDAggregatorTest {
28 |
29 | private static final String TEST_NAME = "StatsDAggregatorTest";
30 | private static final int STATSD_SERVER_PORT = 17254;
31 | private static DummyStatsDServer server;
32 | private static FakeProcessor fakeProcessor;
33 |
34 | private static Logger log = Logger.getLogger(TEST_NAME);
35 |
36 | private static final ExecutorService executor = Executors.newFixedThreadPool(2, new ThreadFactory() {
37 | final ThreadFactory delegate = Executors.defaultThreadFactory();
38 | @Override public Thread newThread(final Runnable runnable) {
39 | final Thread result = delegate.newThread(runnable);
40 | result.setName(TEST_NAME + result.getName());
41 | result.setDaemon(true);
42 | return result;
43 | }
44 | });
45 |
46 | @Rule
47 | public final EnvironmentVariables environmentVariables = new EnvironmentVariables();
48 |
49 | private static final StatsDClientErrorHandler NO_OP_HANDLER = new StatsDClientErrorHandler() {
50 | @Override public void handle(final Exception ex) { /* No-op */ }
51 | };
52 |
53 | public static class FakeMessage extends NumericMessage {
54 | protected FakeMessage(String aspect, Message.Type type, T value) {
55 | super(aspect, type, value, null);
56 | }
57 |
58 | @Override
59 | protected boolean writeTo(StringBuilder builder, int capacity, String containerID) {
60 | return false;
61 | }
62 | }
63 |
64 | public static class FakeAlphaMessage extends AlphaNumericMessage {
65 | protected FakeAlphaMessage(String aspect, Message.Type type, String value) {
66 | super(aspect, type, value, null);
67 | }
68 |
69 | @Override
70 | protected boolean writeTo(StringBuilder builder, int capacity, String containerID) {
71 | return false;
72 | }
73 | }
74 |
75 |
76 | // fakeProcessor store messages from the telemetry only
77 | public static class FakeProcessor extends StatsDProcessor {
78 |
79 | private final Queue messages;
80 | private final AtomicInteger messageSent = new AtomicInteger(0);
81 | private final AtomicInteger messageAggregated = new AtomicInteger(0);
82 |
83 | FakeProcessor(final StatsDClientErrorHandler handler) throws Exception {
84 | super(0, handler, 0, 1, 1, 0, 0, new StatsDThreadFactory(), null);
85 | this.messages = new ConcurrentLinkedQueue<>();
86 | }
87 |
88 |
89 | private class FakeProcessingTask extends StatsDProcessor.ProcessingTask {
90 | @Override
91 | protected void processLoop() {
92 |
93 | while (!shutdown) {
94 | final Message message = messages.poll();
95 | if (message == null) {
96 |
97 | try{
98 | Thread.sleep(50L);
99 | } catch (InterruptedException e) {}
100 |
101 | continue;
102 | }
103 |
104 | if (aggregator.aggregateMessage(message)) {
105 | messageAggregated.incrementAndGet();
106 | continue;
107 | }
108 |
109 | // otherwise just "send" it
110 | messageSent.incrementAndGet();
111 | }
112 | }
113 |
114 | @Override
115 | Message getMessage() { return null; }
116 |
117 | @Override
118 | boolean haveMessages() { return false; }
119 | }
120 |
121 | @Override
122 | protected StatsDProcessor.ProcessingTask createProcessingTask() {
123 | return new FakeProcessingTask();
124 | }
125 |
126 | @Override
127 | public boolean send(final Message msg) {
128 | messages.offer(msg);
129 | return true;
130 | }
131 |
132 | public Queue getMessages() {
133 | return messages;
134 | }
135 |
136 | public void clear() {
137 | try {
138 | messages.clear();
139 | highPrioMessages.clear();
140 | } catch (Exception e) {}
141 | }
142 | }
143 |
144 | @BeforeClass
145 | public static void start() throws Exception {
146 | fakeProcessor = new FakeProcessor(NO_OP_HANDLER);
147 |
148 | // set telemetry
149 | Telemetry telemetry = new Telemetry.Builder()
150 | .processor(fakeProcessor)
151 | .build();
152 | fakeProcessor.setTelemetry(telemetry);
153 |
154 | // 15s flush period should be enough for all tests to be done - flushes will be manual
155 | StatsDAggregator aggregator = new StatsDAggregator(fakeProcessor, StatsDAggregator.DEFAULT_SHARDS, 3000L);
156 | fakeProcessor.aggregator = aggregator;
157 | fakeProcessor.startWorkers("StatsD-Test-");
158 | }
159 |
160 | @AfterClass
161 | public static void stop() {
162 | try {
163 | fakeProcessor.shutdown(false);
164 | } catch (InterruptedException e) {
165 | return;
166 | }
167 | }
168 |
169 | @After
170 | public void clear() {
171 | // we should probably clear all queues
172 | fakeProcessor.clear();
173 | }
174 |
175 | public void waitForQueueSize(Queue queue, int size) {
176 |
177 | // Wait for the flush to happen
178 | while (queue.size() != size) {
179 | try {
180 | Thread.sleep(1000L);
181 | } catch (InterruptedException e) {}
182 | }
183 | }
184 |
185 | @Test(timeout = 2000L)
186 | public void aggregate_messages() throws Exception {
187 |
188 | for(int i=0 ; i<10 ; i++) {
189 | fakeProcessor.send(new FakeMessage("some.gauge", Message.Type.GAUGE, 1));
190 | fakeProcessor.send(new FakeMessage("some.count", Message.Type.COUNT, 1));
191 | fakeProcessor.send(new FakeMessage("some.histogram", Message.Type.HISTOGRAM, 1));
192 | fakeProcessor.send(new FakeMessage("some.distribution", Message.Type.DISTRIBUTION, 1));
193 | fakeProcessor.send(new FakeAlphaMessage("some.set", Message.Type.SET, "value"));
194 | }
195 |
196 | waitForQueueSize(fakeProcessor.messages, 0);
197 |
198 | // 10 gauges, 10 counts, 10 sets
199 | assertEquals(30, fakeProcessor.messageAggregated.get());
200 | // 10 histogram, 10 distribution
201 | assertEquals(20, fakeProcessor.messageSent.get());
202 |
203 | // wait for aggregator flush...
204 | fakeProcessor.aggregator.flush();
205 |
206 | // 2 metrics (gauge, count) + 1 set, so 3 aggregates
207 | assertEquals(3, fakeProcessor.highPrioMessages.size());
208 |
209 | }
210 |
211 | @Test(timeout = 2000L)
212 | public void aggregation_sharding() throws Exception {
213 | final int iterations = 10;
214 |
215 | for(int i=0 ; i gauge = new FakeMessage("some.gauge", Message.Type.GAUGE, 1) {
218 | @Override
219 | public int hashCode() {
220 | return hash;
221 | }
222 | };
223 | fakeProcessor.send(gauge);
224 | }
225 |
226 | waitForQueueSize(fakeProcessor.messages, 0);
227 |
228 | for (int i=0 ; i map = fakeProcessor.aggregator.aggregateMetrics.get(i);
230 | synchronized (map) {
231 | Iterator> iter = map.entrySet().iterator();
232 | int count = 0;
233 | while (iter.hasNext()) {
234 | count++;
235 | iter.next();
236 | }
237 |
238 | // sharding should be balanced
239 | assertEquals(iterations, count);
240 | }
241 | }
242 | }
243 |
244 | @Test(timeout = 5000L)
245 | public void aggregation_flushing() throws Exception {
246 |
247 | for(int i=0 ; i<10 ; i++) {
248 | fakeProcessor.send(new FakeMessage<>("some.gauge", Message.Type.GAUGE, i));
249 | }
250 |
251 | // processor should auto-flush within 2s
252 | waitForQueueSize(fakeProcessor.highPrioMessages, 1);
253 |
254 | //aggregated message should take last value - 10
255 | NumericMessage message = (NumericMessage)fakeProcessor.highPrioMessages.element();
256 | assertEquals(9, message.getValue());
257 |
258 | }
259 |
260 | @Test(timeout = 5000L)
261 | public void test_aggregation_degradation_to_treenodes() {
262 | fakeProcessor.aggregator.flush();
263 | fakeProcessor.clear();
264 | // these counts have been determined to trigger treeification of the message aggregates
265 | int numMessages = 10000;
266 | int numTags = 100;
267 | Assume.assumeTrue("assertions depend on divisibility",numMessages % numTags == 0);
268 | String[][] tags = new String[numTags][];
269 | for (int i = 0; i < numTags; i++) {
270 | tags[i] = new String[] {String.valueOf(i)};
271 | }
272 | for (int i = 0; i < numMessages; i++) {
273 | fakeProcessor.send(new NumericMessage("some.counter", Message.Type.COUNT, 1, tags[i % numTags]) {
274 | @Override
275 | boolean writeTo(StringBuilder builder, int capacity, String containerID) {
276 | return false;
277 | }
278 |
279 | @Override
280 | public int hashCode() {
281 | // provoke collisions
282 | return 0;
283 | }
284 | });
285 | }
286 | waitForQueueSize(fakeProcessor.messages, 0);
287 | fakeProcessor.aggregator.flush();
288 | assertEquals(numTags, fakeProcessor.highPrioMessages.size());
289 | for (int i = 0; i < numTags; i++) {
290 | Message message = fakeProcessor.highPrioMessages.poll();
291 | assertTrue(message instanceof NumericMessage);
292 | assertEquals(numMessages / numTags, ((NumericMessage) message).value.intValue());
293 | }
294 | }
295 | }
296 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/StatsDTestMessage.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | class StatsDTestMessage extends NumericMessage {
4 | final double sampleRate; // NaN for none
5 |
6 | protected StatsDTestMessage(String aspect, Message.Type type, T value, double sampleRate, String[] tags) {
7 | super(aspect, type, value, tags);
8 | this.sampleRate = sampleRate;
9 | }
10 |
11 | @Override
12 | public final boolean writeTo(StringBuilder builder, int capacity, String containerID) {
13 | builder.append("test.").append(aspect).append(':');
14 | writeValue(builder);
15 | builder.append('|').append(type);
16 | if (!Double.isNaN(sampleRate)) {
17 | builder.append('|').append('@').append(NonBlockingStatsDClient.format(NonBlockingStatsDClient.SAMPLE_RATE_FORMATTER, sampleRate));
18 | }
19 | NonBlockingStatsDClient.tagString(this.tags, "", builder);
20 | if (containerID != null && !containerID.isEmpty()) {
21 | builder.append("|c:").append(containerID);
22 | }
23 |
24 | builder.append('\n');
25 | return false;
26 | }
27 |
28 | protected void writeValue(StringBuilder builder) {
29 | builder.append(NonBlockingStatsDClient.format(NonBlockingStatsDClient.NUMBER_FORMATTER, this.value));
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/TestHelpers.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | public class TestHelpers
4 | {
5 | static boolean isLinux() {
6 | return System.getProperty("os.name").toLowerCase().contains("linux");
7 | }
8 |
9 | static boolean isMac() {
10 | return System.getProperty("os.name").toLowerCase().contains("mac");
11 | }
12 |
13 | // Check if jnr.unixsocket is on the classpath.
14 | static boolean isJnrAvailable() {
15 | try {
16 | Class.forName("jnr.unixsocket.UnixDatagramChannel");
17 | return true;
18 | } catch (ClassNotFoundException e) {
19 | return false;
20 | }
21 | }
22 |
23 | static boolean isUdsAvailable() {
24 | return (isLinux() || isMac()) && isJnrAvailable();
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/UDPDummyStatsDServer.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.io.IOException;
4 | import java.net.InetSocketAddress;
5 | import java.nio.ByteBuffer;
6 | import java.nio.channels.DatagramChannel;
7 |
8 | public class UDPDummyStatsDServer extends DummyStatsDServer {
9 | private final DatagramChannel server;
10 |
11 | public UDPDummyStatsDServer(int port) throws IOException {
12 | server = DatagramChannel.open();
13 | server.bind(new InetSocketAddress(port));
14 | this.listen();
15 | }
16 |
17 | @Override
18 | protected boolean isOpen() {
19 | return server.isOpen();
20 | }
21 |
22 | @Override
23 | protected void receive(ByteBuffer packet) throws IOException {
24 | server.receive(packet);
25 | }
26 |
27 | public void close() throws IOException {
28 | try {
29 | server.close();
30 | } catch (Exception e) {
31 | //ignore
32 | }
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/UnixDatagramSocketDummyStatsDServer.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.io.IOException;
4 | import java.nio.ByteBuffer;
5 | import java.nio.channels.DatagramChannel;
6 | import jnr.unixsocket.UnixDatagramChannel;
7 | import jnr.unixsocket.UnixSocketAddress;
8 |
9 | import static com.timgroup.statsd.NonBlockingStatsDClient.DEFAULT_UDS_MAX_PACKET_SIZE_BYTES;
10 |
11 | public class UnixDatagramSocketDummyStatsDServer extends DummyStatsDServer {
12 | private final DatagramChannel server;
13 | UnixSocketAddress addr;
14 |
15 | public UnixDatagramSocketDummyStatsDServer(String socketPath) throws IOException {
16 | server = UnixDatagramChannel.open();
17 | addr = new UnixSocketAddress(socketPath);
18 | server.bind(addr);
19 | this.listen();
20 | }
21 |
22 | @Override
23 | protected boolean isOpen() {
24 | return server.isOpen();
25 | }
26 |
27 | protected void receive(ByteBuffer packet) throws IOException {
28 | server.receive(packet);
29 | }
30 |
31 | public void close() throws IOException {
32 | if (!server.isOpen()) {
33 | return;
34 | }
35 | thread.interrupt();
36 | // JNR doesn't interrupt syscalls when a thread is interrupted, so we send a dummy message
37 | // to wake the thread up.
38 | int sent = server.send(ByteBuffer.wrap(new byte[]{1}), addr);
39 | if (sent == 0) {
40 | throw new IOException("failed to send wake up call to the server thread");
41 | }
42 | server.close();
43 | try {
44 | thread.join();
45 | } catch (Exception e) {
46 | throw new IOException(e);
47 | }
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/UnixSocketTest.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.util.logging.Logger;
4 | import org.junit.After;
5 | import org.junit.Assume;
6 | import org.junit.Before;
7 | import org.junit.BeforeClass;
8 | import org.junit.Test;
9 | import java.io.IOException;
10 | import java.io.File;
11 | import java.nio.file.Files;
12 |
13 | import static org.hamcrest.MatcherAssert.assertThat;
14 | import static org.hamcrest.Matchers.contains;
15 | import static org.hamcrest.Matchers.nullValue;
16 | import static org.hamcrest.Matchers.containsString;
17 | import static org.hamcrest.Matchers.hasItem;
18 | import static org.junit.Assert.assertEquals;
19 |
20 | public class UnixSocketTest implements StatsDClientErrorHandler {
21 | private static File tmpFolder;
22 | private static NonBlockingStatsDClient client;
23 | private static NonBlockingStatsDClient clientAggregate;
24 | private static DummyStatsDServer server;
25 | private static File socketFile;
26 |
27 | private volatile Exception lastException = new Exception();
28 |
29 | private static Logger log = Logger.getLogger(StatsDClientErrorHandler.class.getName());
30 |
31 | public synchronized void handle(Exception exception) {
32 | log.info("Got exception: " + exception);
33 | lastException = exception;
34 | }
35 |
36 | @BeforeClass
37 | public static void supportedOnly() throws IOException {
38 | Assume.assumeTrue(TestHelpers.isUdsAvailable());
39 | }
40 |
41 | @Before
42 | public void start() throws IOException {
43 | tmpFolder = Files.createTempDirectory(System.getProperty("java-dsd-test")).toFile();
44 | tmpFolder.deleteOnExit();
45 | socketFile = new File(tmpFolder, "socket.sock");
46 | socketFile.deleteOnExit();
47 |
48 | server = new UnixDatagramSocketDummyStatsDServer(socketFile.toString());
49 |
50 | client = new NonBlockingStatsDClientBuilder().prefix("my.prefix")
51 | .hostname(socketFile.toString())
52 | .port(0)
53 | .queueSize(1)
54 | .timeout(1) // non-zero timeout to ensure exception triggered if socket buffer full.
55 | .socketBufferSize(1024 * 1024)
56 | .enableAggregation(false)
57 | .errorHandler(this)
58 | .originDetectionEnabled(false)
59 | .build();
60 |
61 | clientAggregate = new NonBlockingStatsDClientBuilder().prefix("my.prefix")
62 | .hostname(socketFile.toString())
63 | .port(0)
64 | .queueSize(1)
65 | .timeout(1) // non-zero timeout to ensure exception triggered if socket buffer full.
66 | .socketBufferSize(1024 * 1024)
67 | .enableAggregation(false)
68 | .errorHandler(this)
69 | .originDetectionEnabled(false)
70 | .build();
71 | }
72 |
73 | @After
74 | public void stop() throws Exception {
75 | client.stop();
76 | clientAggregate.stop();
77 | server.close();
78 | }
79 |
80 | @Test
81 | public void assert_default_uds_size() throws Exception {
82 | assertEquals(client.statsDProcessor.bufferPool.getBufferSize(), NonBlockingStatsDClient.DEFAULT_UDS_MAX_PACKET_SIZE_BYTES);
83 | }
84 |
85 | @Test(timeout = 5000L)
86 | public void sends_to_statsd() throws Exception {
87 | for(long i = 0; i < 5 ; i++) {
88 | client.gauge("mycount", i);
89 | server.waitForMessage();
90 | String expected = String.format("my.prefix.mycount:%d|g", i);
91 | assertThat(server.messagesReceived(), contains(expected));
92 | server.clear();
93 | }
94 | assertThat(lastException.getMessage(), nullValue());
95 | }
96 |
97 | @Test(timeout = 10000L)
98 | public void resist_dsd_restart() throws Exception {
99 | // Send one metric, check that it works.
100 | client.gauge("mycount", 10);
101 | server.waitForMessage();
102 | assertThat(server.messagesReceived(), contains("my.prefix.mycount:10|g"));
103 | server.clear();
104 | assertThat(lastException.getMessage(), nullValue());
105 |
106 | // Close the server, client should throw an IOException
107 | server.close();
108 |
109 | client.gauge("mycount", 20);
110 | while(lastException.getMessage() == null) {
111 | Thread.sleep(10);
112 | }
113 | assertThat(lastException.getMessage(), containsString("Connection refused"));
114 |
115 | // Delete the socket file, client should throw an IOException
116 | socketFile.delete();
117 | lastException = new Exception();
118 |
119 | client.gauge("mycount", 21);
120 | while(lastException.getMessage() == null) {
121 | Thread.sleep(10);
122 | }
123 | assertThat(lastException.getMessage(), containsString("No such file or directory"));
124 |
125 | // Re-open the server, next send should work OK
126 | lastException = new Exception();
127 | DummyStatsDServer server2 = new UnixDatagramSocketDummyStatsDServer(socketFile.toString());
128 |
129 | client.gauge("mycount", 30);
130 |
131 | server2.waitForMessage();
132 | assertThat(server2.messagesReceived(), hasItem("my.prefix.mycount:30|g"));
133 |
134 | server2.clear();
135 | assertThat(lastException.getMessage(), nullValue());
136 | server2.close();
137 | }
138 |
139 | @Test(timeout = 10000L)
140 | public void resist_dsd_timeout() throws Exception {
141 | client.gauge("mycount", 10);
142 | server.waitForMessage();
143 | assertThat(server.messagesReceived(), contains("my.prefix.mycount:10|g"));
144 | server.clear();
145 | assertThat(lastException.getMessage(), nullValue());
146 |
147 | // Freeze the server to simulate dsd being overwhelmed
148 | server.freeze();
149 | while (lastException.getMessage() == null) {
150 | client.gauge("mycount", 20);
151 | Thread.sleep(10); // We need to fill the buffer, setting a shorter sleep
152 | }
153 | String excMessage = TestHelpers.isLinux() ? "Resource temporarily unavailable" : "No buffer space available";
154 | assertThat(lastException.getMessage(), containsString(excMessage));
155 |
156 | // Make sure we recover after we resume listening
157 | server.clear();
158 | server.unfreeze();
159 |
160 | // Now make sure we can receive gauges with 30
161 | while (!server.messagesReceived().contains("my.prefix.mycount:30|g")) {
162 | server.clear();
163 | client.gauge("mycount", 30);
164 | server.waitForMessage();
165 | }
166 | assertThat(server.messagesReceived(), hasItem("my.prefix.mycount:30|g"));
167 | server.clear();
168 | }
169 | }
170 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/UnixStreamSocketDummyStatsDServer.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.io.IOException;
4 | import java.nio.Buffer;
5 | import java.nio.ByteBuffer;
6 | import java.nio.ByteOrder;
7 | import java.nio.channels.SocketChannel;
8 | import java.util.concurrent.ConcurrentLinkedQueue;
9 | import java.util.logging.Logger;
10 | import jnr.unixsocket.UnixServerSocketChannel;
11 | import jnr.unixsocket.UnixSocketAddress;
12 | import jnr.unixsocket.UnixSocketChannel;
13 |
14 | import static com.timgroup.statsd.NonBlockingStatsDClient.DEFAULT_UDS_MAX_PACKET_SIZE_BYTES;
15 |
16 | public class UnixStreamSocketDummyStatsDServer extends DummyStatsDServer {
17 | private final UnixServerSocketChannel server;
18 | private final ConcurrentLinkedQueue channels = new ConcurrentLinkedQueue<>();
19 |
20 | private final Logger logger = Logger.getLogger(UnixStreamSocketDummyStatsDServer.class.getName());
21 |
22 | public UnixStreamSocketDummyStatsDServer(String socketPath) throws IOException {
23 | server = UnixServerSocketChannel.open();
24 | server.configureBlocking(true);
25 | server.socket().bind(new UnixSocketAddress(socketPath));
26 | this.listen();
27 | }
28 |
29 | @Override
30 | protected boolean isOpen() {
31 | return server.isOpen();
32 | }
33 |
34 | @Override
35 | protected void receive(ByteBuffer packet) throws IOException {
36 | // This is unused because we re-implement listen() to fit our needs
37 | }
38 |
39 | @Override
40 | protected void listen() {
41 | logger.info("Listening on " + server.getLocalSocketAddress());
42 | Thread thread = new Thread(new Runnable() {
43 | @Override
44 | public void run() {
45 | while(isOpen()) {
46 | if (sleepIfFrozen()) {
47 | continue;
48 | }
49 | try {
50 | logger.info("Waiting for connection");
51 | UnixSocketChannel clientChannel = server.accept();
52 | if (clientChannel != null) {
53 | clientChannel.configureBlocking(true);
54 | try {
55 | logger.info("Accepted connection from " + clientChannel.getRemoteSocketAddress());
56 | } catch (Exception e) {
57 | logger.warning("Failed to get remote socket address");
58 | }
59 | channels.add(clientChannel);
60 | readChannel(clientChannel);
61 | }
62 | } catch (IOException e) {
63 | }
64 | }
65 | }
66 | });
67 | thread.setDaemon(true);
68 | thread.start();
69 | }
70 |
71 | public void readChannel(final UnixSocketChannel clientChannel) {
72 | logger.info("Reading from " + clientChannel);
73 | Thread thread = new Thread(new Runnable() {
74 | @Override
75 | public void run() {
76 | final ByteBuffer packet = ByteBuffer.allocate(DEFAULT_UDS_MAX_PACKET_SIZE_BYTES);
77 |
78 | while(clientChannel.isOpen()) {
79 | if (sleepIfFrozen()) {
80 | continue;
81 | }
82 | ((Buffer)packet).clear(); // Cast necessary to handle Java9 covariant return types
83 | // see: https://jira.mongodb.org/browse/JAVA-2559 for ref.
84 | if (readPacket(clientChannel, packet)) {
85 | handlePacket(packet);
86 | } else {
87 | try {
88 | clientChannel.close();
89 | } catch (IOException e) {
90 | logger.warning("Failed to close channel: " + e);
91 | }
92 | }
93 |
94 | }
95 | logger.info("Disconnected from " + clientChannel);
96 | }
97 | });
98 | thread.setDaemon(true);
99 | thread.start();
100 | }
101 |
102 | private boolean readPacket(SocketChannel channel, ByteBuffer packet) {
103 | try {
104 | ByteBuffer delimiterBuffer = ByteBuffer.allocate(Integer.SIZE / Byte.SIZE).order(ByteOrder.LITTLE_ENDIAN);
105 |
106 | int read = channel.read(delimiterBuffer);
107 |
108 | delimiterBuffer.flip();
109 | if (read <= 0) {
110 | // There was nothing to read
111 | return false;
112 | }
113 |
114 | int packetSize = delimiterBuffer.getInt();
115 | if (packetSize > packet.capacity()) {
116 | throw new IOException("Packet size too large");
117 | }
118 |
119 | packet.limit(packetSize);
120 | while (packet.hasRemaining() && channel.isConnected()) {
121 | channel.read(packet);
122 | }
123 | return true;
124 | } catch (IOException e) {
125 | return false;
126 | }
127 | }
128 |
129 | public void close() throws IOException {
130 | try {
131 | server.close();
132 | for (UnixSocketChannel channel : channels) {
133 | channel.close();
134 | }
135 | } catch (Exception e) {
136 | //ignore
137 | }
138 | }
139 |
140 | }
141 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/UnixStreamSocketTest.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import java.util.logging.Logger;
4 | import org.junit.After;
5 | import org.junit.Assume;
6 | import org.junit.Before;
7 | import org.junit.BeforeClass;
8 | import org.junit.Test;
9 | import java.io.IOException;
10 | import java.io.File;
11 | import java.nio.file.Files;
12 |
13 | import static org.hamcrest.CoreMatchers.anyOf;
14 | import static org.hamcrest.MatcherAssert.assertThat;
15 | import static org.hamcrest.Matchers.contains;
16 | import static org.hamcrest.Matchers.nullValue;
17 | import static org.hamcrest.Matchers.containsString;
18 | import static org.hamcrest.Matchers.hasItem;
19 | import static org.junit.Assert.assertEquals;
20 |
21 | public class UnixStreamSocketTest implements StatsDClientErrorHandler {
22 | private static File tmpFolder;
23 | private static NonBlockingStatsDClient client;
24 | private static NonBlockingStatsDClient clientAggregate;
25 | private static DummyStatsDServer server;
26 | private static File socketFile;
27 |
28 | private volatile Exception lastException = new Exception();
29 |
30 | private static Logger log = Logger.getLogger(StatsDClientErrorHandler.class.getName());
31 |
32 | public synchronized void handle(Exception exception) {
33 | log.info("Got exception: " + exception);
34 | lastException = exception;
35 | }
36 |
37 | @BeforeClass
38 | public static void supportedOnly() throws IOException {
39 | Assume.assumeTrue(TestHelpers.isUdsAvailable());
40 | }
41 |
42 | @Before
43 | public void start() throws IOException {
44 | tmpFolder = Files.createTempDirectory(System.getProperty("java-dsd-test")).toFile();
45 | tmpFolder.deleteOnExit();
46 | socketFile = new File(tmpFolder, "socket.sock");
47 | socketFile.deleteOnExit();
48 |
49 | server = new UnixStreamSocketDummyStatsDServer(socketFile.toString());
50 |
51 | client = new NonBlockingStatsDClientBuilder().prefix("my.prefix")
52 | .address("unixstream://" + socketFile.getPath())
53 | .port(0)
54 | .queueSize(1)
55 | .timeout(500) // non-zero timeout to ensure exception triggered if socket buffer full.
56 | .connectionTimeout(500)
57 | .socketBufferSize(1024 * 1024)
58 | .enableAggregation(false)
59 | .errorHandler(this)
60 | .originDetectionEnabled(false)
61 | .build();
62 |
63 | clientAggregate = new NonBlockingStatsDClientBuilder().prefix("my.prefix")
64 | .address("unixstream://" + socketFile.getPath())
65 | .port(0)
66 | .queueSize(1)
67 | .timeout(500) // non-zero timeout to ensure exception triggered if socket buffer full.
68 | .connectionTimeout(500)
69 | .socketBufferSize(1024 * 1024)
70 | .enableAggregation(false)
71 | .errorHandler(this)
72 | .originDetectionEnabled(false)
73 | .build();
74 | }
75 |
76 | @After
77 | public void stop() throws Exception {
78 | client.stop();
79 | clientAggregate.stop();
80 | server.close();
81 | }
82 |
83 | @Test
84 | public void assert_default_uds_size() throws Exception {
85 | assertEquals(client.statsDProcessor.bufferPool.getBufferSize(), NonBlockingStatsDClient.DEFAULT_UDS_MAX_PACKET_SIZE_BYTES);
86 | }
87 |
88 | @Test(timeout = 5000L)
89 | public void sends_to_statsd() throws Exception {
90 | for(long i = 0; i < 5 ; i++) {
91 | client.gauge("mycount", i);
92 | server.waitForMessage();
93 | String expected = String.format("my.prefix.mycount:%d|g", i);
94 | assertThat(server.messagesReceived(), contains(expected));
95 | server.clear();
96 | }
97 | assertThat(lastException.getMessage(), nullValue());
98 | }
99 |
100 | @Test(timeout = 10000L)
101 | public void resist_dsd_restart() throws Exception {
102 | // Send one metric, check that it works.
103 | client.gauge("mycount", 10);
104 | server.waitForMessage();
105 | assertThat(server.messagesReceived(), contains("my.prefix.mycount:10|g"));
106 | server.clear();
107 | assertThat(lastException.getMessage(), nullValue());
108 |
109 | // Close the server, client should throw an IOException
110 | server.close();
111 |
112 | client.gauge("mycount", 20);
113 | while(lastException.getMessage() == null) {
114 | Thread.sleep(10);
115 | }
116 | // Depending on the state of the client at that point we might get different messages.
117 | assertThat(lastException.getMessage(), anyOf(containsString("Connection refused"), containsString("Broken pipe")));
118 |
119 | // Delete the socket file, client should throw an IOException
120 | lastException = new Exception();
121 | socketFile.delete();
122 |
123 | client.gauge("mycount", 21);
124 | while(lastException.getMessage() == null) {
125 | Thread.sleep(10);
126 | }
127 | assertThat(lastException.getMessage(), containsString("No such file or directory"));
128 |
129 | // Re-open the server, next send should work OK
130 | DummyStatsDServer server2;
131 | server2 = new UnixStreamSocketDummyStatsDServer(socketFile.toString());
132 |
133 | lastException = new Exception();
134 |
135 | client.gauge("mycount", 30);
136 | server2.waitForMessage();
137 | assertThat(server2.messagesReceived(), hasItem("my.prefix.mycount:30|g"));
138 |
139 | server2.clear();
140 | assertThat(lastException.getMessage(), nullValue());
141 | server2.close();
142 | }
143 |
144 | @Test(timeout = 10000L)
145 | public void resist_dsd_timeout() throws Exception {
146 | client.gauge("mycount", 10);
147 | server.waitForMessage();
148 | assertThat(server.messagesReceived(), contains("my.prefix.mycount:10|g"));
149 | server.clear();
150 | assertThat(lastException.getMessage(), nullValue());
151 |
152 | // Freeze the server to simulate dsd being overwhelmed
153 | server.freeze();
154 |
155 | while (lastException.getMessage() == null) {
156 | client.gauge("mycount", 20);
157 |
158 | }
159 | String excMessage = "Write timed out";
160 | assertThat(lastException.getMessage(), containsString(excMessage));
161 |
162 | // Make sure we recover after we resume listening
163 | server.clear();
164 | server.unfreeze();
165 |
166 | // Now make sure we can receive gauges with 30
167 | while (!server.messagesReceived().contains("my.prefix.mycount:30|g")) {
168 | server.clear();
169 | client.gauge("mycount", 30);
170 | server.waitForMessage();
171 | }
172 | assertThat(server.messagesReceived(), hasItem("my.prefix.mycount:30|g"));
173 | server.clear();
174 | }
175 |
176 | @Test(timeout = 5000L)
177 | public void stream_uds_has_uds_buffer_size() throws Exception {
178 | final NonBlockingStatsDClient client = new NonBlockingStatsDClientBuilder()
179 | .prefix("my.prefix")
180 | .address("unixstream:///foo")
181 | .containerID("fake-container-id")
182 | .build();
183 |
184 | assertEquals(client.statsDProcessor.bufferPool.getBufferSize(), NonBlockingStatsDClient.DEFAULT_UDS_MAX_PACKET_SIZE_BYTES);
185 | }
186 |
187 | @Test(timeout = 5000L)
188 | public void max_packet_size_override() throws Exception {
189 | final NonBlockingStatsDClient client = new NonBlockingStatsDClientBuilder()
190 | .prefix("my.prefix")
191 | .address("unixstream:///foo")
192 | .containerID("fake-container-id")
193 | .maxPacketSizeBytes(576)
194 | .build();
195 |
196 | assertEquals(client.statsDProcessor.bufferPool.getBufferSize(), 576);
197 | }
198 | }
199 |
--------------------------------------------------------------------------------
/src/test/java/com/timgroup/statsd/Utf8Test.java:
--------------------------------------------------------------------------------
1 | package com.timgroup.statsd;
2 |
3 | import org.junit.Test;
4 |
5 | import java.nio.ByteBuffer;
6 | import java.nio.CharBuffer;
7 | import java.nio.charset.CharacterCodingException;
8 | import java.nio.charset.CharsetEncoder;
9 | import java.nio.charset.CodingErrorAction;
10 | import java.nio.charset.StandardCharsets;
11 |
12 | import static java.lang.Character.MIN_SURROGATE;
13 | import static org.hamcrest.MatcherAssert.assertThat;
14 | import static org.hamcrest.Matchers.equalTo;
15 |
16 | public class Utf8Test {
17 |
18 | @Test
19 | public void should_handle_malformed_inputs() throws CharacterCodingException {
20 | shouldHandleMalformedInput("foo" + MIN_SURROGATE + "bar");
21 | shouldHandleMalformedInput("🍻☀️😎🏖️" + MIN_SURROGATE + "🍻☀️😎🏖️");
22 | }
23 |
24 | private static void shouldHandleMalformedInput(String malformedInput) throws CharacterCodingException {
25 | CharsetEncoder utf8Encoder = StandardCharsets.UTF_8.newEncoder()
26 | .onMalformedInput(CodingErrorAction.REPLACE)
27 | .onUnmappableCharacter(CodingErrorAction.REPLACE);
28 | ByteBuffer encoded = utf8Encoder.encode(CharBuffer.wrap(malformedInput));
29 |
30 | assertThat(Utf8.encodedLength(malformedInput), equalTo(encoded.limit()));
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/style.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
76 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
101 |
102 |
103 |
105 |
106 |
107 |
108 |
110 |
111 |
112 |
113 |
115 |
116 |
117 |
118 |
119 |
120 |
122 |
123 |
124 |
125 |
127 |
128 |
129 |
130 |
132 |
133 |
134 |
135 |
137 |
139 |
141 |
143 |
144 |
145 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 |
163 |
164 |
165 |
166 |
167 |
168 |
169 |
170 |
171 |
172 |
173 |
174 |
175 |
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 |
187 |
188 |
189 |
190 |
191 |
192 |
193 |
194 |
195 |
196 |
197 |
198 |
200 |
201 |
202 |
203 |
204 |
205 |
206 |
207 |
208 |
209 |
210 |
--------------------------------------------------------------------------------
/vendor/buildlib/hamcrest-core-1.3.0RC2.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DataDog/java-dogstatsd-client/ae5c0f79127e57a0a0c0d9fcd7b371d5cf862afa/vendor/buildlib/hamcrest-core-1.3.0RC2.jar
--------------------------------------------------------------------------------
/vendor/buildlib/hamcrest-library-1.3.0RC2.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DataDog/java-dogstatsd-client/ae5c0f79127e57a0a0c0d9fcd7b371d5cf862afa/vendor/buildlib/hamcrest-library-1.3.0RC2.jar
--------------------------------------------------------------------------------
/vendor/buildlib/junit-dep-4.10.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DataDog/java-dogstatsd-client/ae5c0f79127e57a0a0c0d9fcd7b371d5cf862afa/vendor/buildlib/junit-dep-4.10.jar
--------------------------------------------------------------------------------
/vendor/src/junit-dep-4.10-sources.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DataDog/java-dogstatsd-client/ae5c0f79127e57a0a0c0d9fcd7b371d5cf862afa/vendor/src/junit-dep-4.10-sources.jar
--------------------------------------------------------------------------------