src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
MessicVersion implements Comparable<MessicVersion> { @Override public boolean equals( Object obj ) { if ( obj instanceof MessicVersion ) { return ( this.compareTo( (MessicVersion) obj ) == 0 ? true : false ); } else { return false; } } MessicVersion( String version ); @Override String toString(); @Override boolean equals( Object obj ); @Override int compareTo( MessicVersion other ); public String sversion; public int version; public int revision; public int patch; public String semantic; public int semanticPatch; } | @Test public void testConstruction() { MessicVersion mv = new MessicVersion( "1.0.3" ); Assert.assertTrue( mv.version == 1 ); Assert.assertTrue( mv.revision == 0 ); Assert.assertTrue( mv.patch == 3 ); Assert.assertTrue( mv.semantic.equals( "" ) ); Assert.assertTrue( mv.semanticPatch == 0 ); mv = new MessicVersion( "5.3.1" ); Assert.assertTrue( mv.version == 5 ); Assert.assertTrue( mv.revision == 3 ); Assert.assertTrue( mv.patch == 1 ); Assert.assertTrue( mv.semantic.equals( "" ) ); Assert.assertTrue( mv.semanticPatch == 0 ); mv = new MessicVersion( "111.3.0-alpha" ); Assert.assertTrue( mv.version == 111 ); Assert.assertTrue( mv.revision == 3 ); Assert.assertTrue( mv.patch == 0 ); Assert.assertTrue( mv.semantic.equals( "alpha" ) ); Assert.assertTrue( mv.semanticPatch == 0 ); mv = new MessicVersion( "0.0.0-beta" ); Assert.assertTrue( mv.version == 0 ); Assert.assertTrue( mv.revision == 0 ); Assert.assertTrue( mv.patch == 0 ); Assert.assertTrue( mv.semantic.equals( "beta" ) ); Assert.assertTrue( mv.semanticPatch == 0 ); mv = new MessicVersion( "3.1.0-rc" ); Assert.assertTrue( mv.version == 3 ); Assert.assertTrue( mv.revision == 1 ); Assert.assertTrue( mv.patch == 0 ); Assert.assertTrue( mv.semantic.equals( "rc" ) ); Assert.assertTrue( mv.semanticPatch == 0 ); mv = new MessicVersion( "111.3.0-other" ); Assert.assertTrue( mv.version == 111 ); Assert.assertTrue( mv.revision == 3 ); Assert.assertTrue( mv.patch == 0 ); Assert.assertTrue( mv.semantic.equals( "other" ) ); Assert.assertTrue( mv.semanticPatch == 0 ); mv = new MessicVersion( "111.3.0-beta.42" ); Assert.assertTrue( mv.version == 111 ); Assert.assertTrue( mv.revision == 3 ); Assert.assertTrue( mv.patch == 0 ); Assert.assertTrue( mv.semantic.equals( "beta" ) ); Assert.assertTrue( mv.semanticPatch == 42 ); mv = new MessicVersion( "1.1.0-alpha.122" ); Assert.assertTrue( mv.version == 1 ); Assert.assertTrue( mv.revision == 1 ); Assert.assertTrue( mv.patch == 0 ); Assert.assertTrue( mv.semantic.equals( "alpha" ) ); Assert.assertTrue( mv.semanticPatch == 122 ); } |
Util { public static String replaceIllegalFilenameCharactersNew( String filename, char replacementCharacter ) { String result = filename.replaceAll( ILLEGAL_FILENAME_OPENENCAPSULATE_CHARS_NEW, "[" ); result = result.replaceAll( ILLEGAL_FILENAME_CLOSEENCAPSULATE_CHARS_NEW, "]" ); result = result.replaceAll( ILLEGAL_FILENAME_SEPARATOR_CHARS_NEW, "-" ); Matcher matcher = ILLEGAL_FILENAME_CHARS_PATTERN_NEW.matcher( result ); result = matcher.replaceAll( replacementCharacter + "" ); return result; } static boolean isInteger( String str ); static byte[] readInputStream( InputStream is ); static void streamFile( String filePath, OutputStream os ); static byte[] readFile( String filePath ); static String leftZeroPadding( int number, int howManyChar ); static String replaceIllegalFilenameCharactersOld( String filename, char replacementCharacter ); static boolean haveFilenameIllegalCharactersOld( String filename ); static String replaceIllegalFilenameCharactersNew( String filename, char replacementCharacter ); static boolean haveFilenameIllegalCharactersNew( String filename ); static int areThereNumbers( String str ); static String addPartsFromArray( String[] str, int from, int to, String separator ); static void zipFiles( List<File> files, OutputStream os ); static void zipFolder( String folderpath, String baseSubfolder, OutputStream os ); static final void listFiles( String basePath, List<File> files ); static BufferedImage ImagedeepCopy( BufferedImage bi ); static String getInternalIp(); static int randInt( int min, int max ); static File getRollFileNumber( File file ); static final String GENERIC_BASE_STORE_PATH_VAR; static final String DEFAULT_EXTENSION; static final String TEMPORAL_FOLDER; static final String ILLEGAL_FILENAME_CHARS_OLD; static final String ILLEGAL_FILENAME_CHARS_NEW; static final String ILLEGAL_FILENAME_OPENENCAPSULATE_CHARS_NEW; static final String ILLEGAL_FILENAME_CLOSEENCAPSULATE_CHARS_NEW; static final String ILLEGAL_FILENAME_SEPARATOR_CHARS_NEW; static final Pattern ILLEGAL_FILENAME_CHARS_PATTERN_OLD; static final Pattern ILLEGAL_FILENAME_CHARS_PATTERN_NEW; static final Pattern ILLEGAL_FILENAME_OPENENCAPSULATE_CHARS_PATTERN_NEW; static final Pattern ILLEGAL_FILENAME_CLOSEENCAPSULATE_CHARS_PATTERN_NEW; } | @Test public void testReplaceIllegalFilenameCharacters() { String fileName = "04-From?::/let's see.mp3"; String result = Util.replaceIllegalFilenameCharactersNew( fileName, '_' ); Assert.assertTrue( result.equals( "04-From_-let's see.mp3" ) ); fileName = "04-Fr^om /et's see\\.m*3"; result = Util.replaceIllegalFilenameCharactersNew( fileName, '_' ); Assert.assertTrue( result.equals( "04-Fr_om -et's see-.m_3" ) ); fileName = "07 - (You Are) This {Body} of <M>il|k.mp3"; result = Util.replaceIllegalFilenameCharactersNew( fileName, '_' ); Assert.assertTrue( result.equals( "07 - (You Are) This [Body] of [M]il-k.mp3" ) ); } |
Util { public static File getRollFileNumber( File file ) { File fresult = file; if ( !file.isDirectory() && file.exists() ) { file.getName(); String name = FilenameUtils.getBaseName( file.getName() ); String ext = FilenameUtils.getExtension( file.getName() ); String parent = file.getParent(); int indexOf_ = name.lastIndexOf( "_" ); if ( indexOf_ > 0 ) { String first = name.substring( 0, indexOf_ ); String last = name.substring( indexOf_ + 1 ); if ( isInteger( last ) ) { int number = Integer.valueOf( last ); number++; fresult = new File( parent + File.separatorChar + first + "_" + number + "." + ext ); } else { fresult = new File( parent + File.separatorChar + first + "_" + last + "_1." + ext ); } } else { fresult = new File( parent + File.separatorChar + name + "_1." + ext ); } } return fresult; } static boolean isInteger( String str ); static byte[] readInputStream( InputStream is ); static void streamFile( String filePath, OutputStream os ); static byte[] readFile( String filePath ); static String leftZeroPadding( int number, int howManyChar ); static String replaceIllegalFilenameCharactersOld( String filename, char replacementCharacter ); static boolean haveFilenameIllegalCharactersOld( String filename ); static String replaceIllegalFilenameCharactersNew( String filename, char replacementCharacter ); static boolean haveFilenameIllegalCharactersNew( String filename ); static int areThereNumbers( String str ); static String addPartsFromArray( String[] str, int from, int to, String separator ); static void zipFiles( List<File> files, OutputStream os ); static void zipFolder( String folderpath, String baseSubfolder, OutputStream os ); static final void listFiles( String basePath, List<File> files ); static BufferedImage ImagedeepCopy( BufferedImage bi ); static String getInternalIp(); static int randInt( int min, int max ); static File getRollFileNumber( File file ); static final String GENERIC_BASE_STORE_PATH_VAR; static final String DEFAULT_EXTENSION; static final String TEMPORAL_FOLDER; static final String ILLEGAL_FILENAME_CHARS_OLD; static final String ILLEGAL_FILENAME_CHARS_NEW; static final String ILLEGAL_FILENAME_OPENENCAPSULATE_CHARS_NEW; static final String ILLEGAL_FILENAME_CLOSEENCAPSULATE_CHARS_NEW; static final String ILLEGAL_FILENAME_SEPARATOR_CHARS_NEW; static final Pattern ILLEGAL_FILENAME_CHARS_PATTERN_OLD; static final Pattern ILLEGAL_FILENAME_CHARS_PATTERN_NEW; static final Pattern ILLEGAL_FILENAME_OPENENCAPSULATE_CHARS_PATTERN_NEW; static final Pattern ILLEGAL_FILENAME_CLOSEENCAPSULATE_CHARS_PATTERN_NEW; } | @Test public void testGetRollFileNumber() throws IOException { File f = new File( "./testFile0" ); File fresult = Util.getRollFileNumber( f ); Assert.assertTrue( fresult.getName().equals( "testFile0" ) ); f = tfolder.newFile( "testFile1.txt" ); fresult = Util.getRollFileNumber( f ); Assert.assertTrue( fresult.getName().equals( "testFile1_1.txt" ) ); f = tfolder.newFile( "testFile_2.txt" ); fresult = Util.getRollFileNumber( f ); Assert.assertTrue( fresult.getName().equals( "testFile_3.txt" ) ); f = tfolder.newFile( "testFile_test.txt" ); fresult = Util.getRollFileNumber( f ); Assert.assertTrue( fresult.getName().equals( "testFile_test_1.txt" ) ); } |
MessicDataSource extends BasicDataSource { @Override public synchronized void setUrl( String url ) { String musicFolder = System.getProperty( "messic.musicfolder" ); if ( musicFolder == null || musicFolder.length() <= 0 ) { musicFolder = System.getProperty( "user.home" ) + File.separatorChar + "messic-data"; } File f = new File( musicFolder ); if ( !f.exists() ) { f.mkdirs(); } String messic_path = f.getAbsolutePath(); messic_path = messic_path.replaceAll( "\\\\", "\\\\\\\\" ); String newURL = url.replaceAll( "MESSIC_PATH", messic_path ); databasePath = messic_path; super.setUrl( newURL ); } @Override synchronized void setUrl( String url ); static String databasePath; } | @Test public void testSetUrl() { MessicDataSource mds = new MessicDataSource(); String urlTest = "jdbc:h2:MESSIC_PATH/db;DB_CLOSE_DELAY=-1"; mds.setUrl( urlTest ); Assert.assertTrue( !mds.getUrl().equals( urlTest ) ); } |
Activator implements BundleActivator { public void start( BundleContext bundleContext ) { try { String sversion = LibShout.get().getVersion(); if ( !sversion.equals( "2.3.1" ) ) { logger.warn( "icecast2 version " + sversion ); } logger.info( "Radio - Icecast2 Started" ); Hashtable<String, String> props = new Hashtable<String, String>(); props.put( MessicRadioPlugin.MESSIC_RADIO_PLUGIN_NAME, MessicRadioPluginIceCast2.NAME ); bundleContext.registerService( MessicRadioPlugin.class.getName(), new MessicRadioPluginIceCast2(), props ); } catch ( Exception e ) { logger.info( "Radio - Icecast2 Not Available" ); } catch ( Error e ) { logger.info( "Radio - Icecast2 Not Available" ); } } void start( BundleContext bundleContext ); void stop( BundleContext bundleContext ); } | @Test public void testStart() { } |
RingStream implements Iterable<E>, Iterator<E> { public Stream<E> streamLimited(int count) { return streamUnlimited().limit(count); } @SafeVarargs RingStream(E... elements); @Override boolean hasNext(); @Override Iterator<E> iterator(); @Override E next(); int size(); Stream<E> streamAll(); Stream<E> streamLimited(int count); Stream<E> streamUnlimited(); @SafeVarargs final RingStream<E> with(E... others); } | @Test public void testLimitedStream() { RingStream<String> s = new RingStream<>("foo", "bar", "baz"); assertTrue(s.streamLimited(2).noneMatch("baz"::equals)); assertTrue(s.streamLimited(2).noneMatch("bar"::equals)); assertTrue(s.streamLimited(2).noneMatch("foo"::equals)); } |
MsgDeliveryTagMapping { public void basicAck(long deliveryTag, boolean multiple) throws IOException { Map<Long, MsgResponse> acks = multiple ? deliveryTags.headMap(deliveryTag, true).descendingMap() : deliveryTags.subMap(deliveryTag, deliveryTag + 1); eachChannelOnce(acks, MsgResult.ACK, multiple, false); acks.clear(); } MsgDeliveryTagMapping(); void basicAck(long deliveryTag, boolean multiple); } | @Test void basicAck() { when(envelope.getDeliveryTag()).thenReturn(40L); Envelope e = map.envelopeWithPseudoDeliveryTag(channel, envelope); assertNotEquals(40L, e.getDeliveryTag()); assertDoesNotThrow(() -> map.basicAck(e.getDeliveryTag(), false)); assertDoesNotThrow(() -> verify(channel).basicAck(40L, false)); } |
MsgDeliveryTagMapping { void basicNack(long deliveryTag, boolean multiple, boolean requeue) throws IOException { Map<Long, MsgResponse> nacks = multiple ? deliveryTags.headMap(deliveryTag, true).descendingMap() : deliveryTags.subMap(deliveryTag, deliveryTag + 1); eachChannelOnce(nacks, MsgResult.NACK, multiple, requeue); nacks.clear(); } MsgDeliveryTagMapping(); void basicAck(long deliveryTag, boolean multiple); } | @Test void basicNack() { when(envelope.getDeliveryTag()).thenReturn(41L); Envelope e = map.envelopeWithPseudoDeliveryTag(channel, envelope); assertNotEquals(41L, e.getDeliveryTag()); assertDoesNotThrow(() -> map.basicNack(e.getDeliveryTag(), false, false)); assertDoesNotThrow(() -> verify(channel).basicNack(41L, false, false)); } |
MsgDeliveryTagMapping { void basicReject(long deliveryTag, boolean requeue) throws IOException { Map<Long, MsgResponse> rejections = deliveryTags.subMap(deliveryTag, deliveryTag + 1); eachChannelOnce(rejections, MsgResult.REJECT, false, requeue); rejections.clear(); } MsgDeliveryTagMapping(); void basicAck(long deliveryTag, boolean multiple); } | @Test void basicReject() { when(envelope.getDeliveryTag()).thenReturn(43L); Envelope e = map.envelopeWithPseudoDeliveryTag(channel, envelope); assertNotEquals(43L, e.getDeliveryTag()); assertDoesNotThrow(() -> map.basicReject(e.getDeliveryTag(), false)); assertDoesNotThrow(() -> verify(channel).basicReject(43L, false)); } |
MsgDeliveryTagMapping { Consumer createConsumerDecorator(Consumer delegate, Channel channel) { return new MappingConsumer(this, delegate, channel); } MsgDeliveryTagMapping(); void basicAck(long deliveryTag, boolean multiple); } | @Test void createConsumerDecorator() { Consumer c = map.createConsumerDecorator(callback, channel); } |
MsgDeliveryTagMapping { Envelope envelopeWithPseudoDeliveryTag(Channel channel, Envelope envelope) { long tag = mapDelivery(channel, envelope.getDeliveryTag()); return new Envelope( tag, envelope.isRedeliver(), envelope.getExchange(), envelope.getRoutingKey()); } MsgDeliveryTagMapping(); void basicAck(long deliveryTag, boolean multiple); } | @Test void mapEnvelope() { when(envelope.getDeliveryTag()).thenReturn(42L); Envelope e = map.envelopeWithPseudoDeliveryTag(channel, envelope); assertNotEquals(42L, e.getDeliveryTag()); } |
Utility { static byte[] encode(BigInteger n) { byte[] encodedN; if (n.signum() == 0) { encodedN = new byte[0]; } else { byte[] nAsByteArray = n.toByteArray(); int firstNonZeroIndex = 0; while ((nAsByteArray[firstNonZeroIndex] == 0) && (firstNonZeroIndex < nAsByteArray.length)) { firstNonZeroIndex++; } encodedN = new byte[nAsByteArray.length - firstNonZeroIndex]; System.arraycopy(nAsByteArray, firstNonZeroIndex, encodedN, 0, nAsByteArray.length - firstNonZeroIndex); } return encodedN; } private Utility(); static byte[] reverse(byte[] source); static byte[] toLEBytes(int i); } | @Test public void testEncode() { assertArrayEquals(TestUtility.cba(0xCA, 0xFE, 0xBA, 0xBE), Utility.encode(BigInteger.valueOf(0xCAFEBABE))); assertArrayEquals(TestUtility.cba(0xCA, 0xFE, 0xBA), Utility.encode(BigInteger.valueOf(0x00CAFEBA))); assertArrayEquals(TestUtility.cba(0xCA, 0xFE), Utility.encode(BigInteger.valueOf(0x0000CAFE))); assertArrayEquals(TestUtility.cba(0xCA), Utility.encode(BigInteger.valueOf(0x000000CA))); assertArrayEquals(new byte[0], Utility.encode(BigInteger.valueOf(0))); } |
FE1 { public BigInteger decrypt(final BigInteger modulus, final BigInteger ciphertext, final byte[] key, final byte[] tweak) throws FPEException { if (modulus == null) { throw new IllegalArgumentException("modulus must not be null."); } if (ciphertext == null) { throw new IllegalArgumentException("ciphertext must not be null."); } if (ciphertext.compareTo(modulus) >= 0) { throw new IllegalArgumentException("Cannot decrypt a number bigger than the modulus (otherwise this wouldn't be format preserving encryption"); } FPEEncryptor encryptor = new FPEEncryptor(key, modulus, tweak); BigInteger[] factors = NumberTheory.factor(modulus); BigInteger firstFactor = factors[0]; BigInteger secondFactor = factors[1]; int rounds = getNumberOfRounds(firstFactor, secondFactor); BigInteger x = ciphertext; for (int round = rounds - 1; round >= 0; round--) { BigInteger w = x.mod(firstFactor); BigInteger right = x.divide(firstFactor); BigInteger left = w.subtract(encryptor.f(round, right)).mod(firstFactor); x = secondFactor.multiply(left).add(right); } return x; } FE1(); BigInteger decrypt(final BigInteger modulus, final BigInteger ciphertext, final byte[] key, final byte[] tweak); BigInteger encrypt(final BigInteger modulus, final BigInteger plaintext, final byte[] key, final byte[] tweak); } | @Test(expected = IllegalArgumentException.class) public void testDecryptTooBigInputBy1() throws FPEException { new FE1().decrypt(BigInteger.valueOf(10000), BigInteger.valueOf(10000), TEST_KEY, TEST_IV); }
@Test(expected = IllegalArgumentException.class) public void testDecryptTooBigInputBy2() throws FPEException { new FE1().decrypt(BigInteger.valueOf(10000), BigInteger.valueOf(10001), TEST_KEY, TEST_IV); }
@Test(expected = IllegalArgumentException.class) public void testDecryptNullModulus() throws FPEException { new FE1().decrypt(null, BigInteger.valueOf(10001), TEST_KEY, TEST_IV); }
@Test(expected = IllegalArgumentException.class) public void testDecryptNullValue() throws FPEException { new FE1().decrypt(BigInteger.valueOf(10001), null, TEST_KEY, TEST_IV); } |
FE1 { public BigInteger encrypt(final BigInteger modulus, final BigInteger plaintext, final byte[] key, final byte[] tweak) throws FPEException { if (modulus == null) { throw new IllegalArgumentException("modulus must not be null."); } if (plaintext == null) { throw new IllegalArgumentException("plaintext must not be null."); } if (plaintext.compareTo(modulus) >= 0) { throw new IllegalArgumentException("Cannot encrypt a number bigger than the modulus (otherwise this wouldn't be format preserving encryption"); } FPEEncryptor encryptor = new FPEEncryptor(key, modulus, tweak); BigInteger[] factors = NumberTheory.factor(modulus); BigInteger firstFactor = factors[0]; BigInteger secondFactor = factors[1]; int rounds = getNumberOfRounds(firstFactor, secondFactor); BigInteger x = plaintext; for (int round = 0; round != rounds; round++) { BigInteger left = x.divide(secondFactor); BigInteger right = x.mod(secondFactor); BigInteger w = left.add(encryptor.f(round, right)).mod(firstFactor); x = firstFactor.multiply(right).add(w); } return x; } FE1(); BigInteger decrypt(final BigInteger modulus, final BigInteger ciphertext, final byte[] key, final byte[] tweak); BigInteger encrypt(final BigInteger modulus, final BigInteger plaintext, final byte[] key, final byte[] tweak); } | @Test(expected = IllegalArgumentException.class) public void testEncryptNullModulus() throws FPEException { new FE1().encrypt(null, BigInteger.valueOf(10001), TEST_KEY, TEST_IV); }
@Test(expected = IllegalArgumentException.class) public void testEncryptNullValue() throws FPEException { new FE1().encrypt(BigInteger.valueOf(10001), null, TEST_KEY, TEST_IV); }
@Test(expected = IllegalArgumentException.class) public void testInvalidKey() throws FPEException { new FE1().encrypt(BigInteger.valueOf(32), BigInteger.valueOf(0), new byte[0], new byte[] { 1, 2, 3, 4, 5 }); }
@Test(expected = IllegalArgumentException.class) public void testTooLargeModulus() throws FPEException { new FE1().encrypt(new BigInteger("100000000000000000000000000000000", 16), BigInteger.valueOf(0), new byte[] { 1, 2, 3, 4, 5 }, new byte[] { 1, 2, 3, 4, 5 }); }
@Test(expected = FPEException.class) public void testPrimeModulusFails() throws FPEException { new FE1().encrypt(BigInteger.valueOf(10007), BigInteger.valueOf(0), TEST_KEY, TEST_IV); }
@Test(expected = IllegalArgumentException.class) public void testNullIV() throws FPEException { new FE1().encrypt(BigInteger.valueOf(10007), BigInteger.valueOf(0), TEST_KEY, null); }
@Test(expected = IllegalArgumentException.class) public void testZeroLengthIV() throws FPEException { new FE1().encrypt(BigInteger.valueOf(10007), BigInteger.valueOf(0), TEST_KEY, new byte[0]); }
@Test(expected = FPEException.class) public void testTooBigModulus() throws FPEException { new FE1().encrypt(BigInteger.valueOf((128 ^ 8) + 1), BigInteger.valueOf(0), TEST_KEY, TEST_IV); }
@Test(expected = IllegalArgumentException.class) public void testEncryptTooBigInputBy1() throws FPEException { new FE1().encrypt(BigInteger.valueOf(10000), BigInteger.valueOf(10000), TEST_KEY, TEST_IV); }
@Test(expected = IllegalArgumentException.class) public void testEncryptTooBigInputBy2() throws FPEException { new FE1().encrypt(BigInteger.valueOf(10000), BigInteger.valueOf(10001), TEST_KEY, TEST_IV); } |
NumberTheory { static int countLowZeroBits(BigInteger n) { int lowZero = 0; if (n.signum() > 0) { byte[] bytes = n.toByteArray(); for (int i = bytes.length - 1; i >= 0; i--) { byte x = bytes[i]; if (x != 0) { lowZero += countTrailingZeros(x); break; } else { lowZero += 8; } } } return lowZero; } private NumberTheory(); } | @Test public void testCountLowZeroBits() { assertEquals(0, NumberTheory.countLowZeroBits(BigInteger.valueOf(0b0))); assertEquals(0, NumberTheory.countLowZeroBits(BigInteger.valueOf(-1))); assertEquals(0, NumberTheory.countLowZeroBits(BigInteger.valueOf(-1000))); assertEquals(8, NumberTheory.countLowZeroBits(BigInteger.valueOf(0b100000000))); assertEquals(7, NumberTheory.countLowZeroBits(BigInteger.valueOf(0b110000000))); assertEquals(0, NumberTheory.countLowZeroBits(BigInteger.valueOf(0b11111111))); assertEquals(1, NumberTheory.countLowZeroBits(BigInteger.valueOf(0b11111110))); assertEquals(2, NumberTheory.countLowZeroBits(BigInteger.valueOf(0b100))); assertEquals(16, NumberTheory.countLowZeroBits(BigInteger.valueOf(0b10000000000000000))); assertEquals(17, NumberTheory.countLowZeroBits(BigInteger.valueOf(0b100000000000000000))); assertEquals(15, NumberTheory.countLowZeroBits(BigInteger.valueOf(0b1000000000000000))); } |
NumberTheory { static int countTrailingZeros(byte n) { for (int i = 0; i != 8; ++i) { if (((n >> i) & 0x01) > 0) { return i; } } return 8; } private NumberTheory(); } | @Test public void testCountTrailingZeros() { assertEquals(8, NumberTheory.countTrailingZeros((byte) 0b0)); assertEquals(0, NumberTheory.countTrailingZeros((byte) 0b1)); assertEquals(1, NumberTheory.countTrailingZeros((byte) 0b11111110)); assertEquals(6, NumberTheory.countTrailingZeros((byte) 0b11000000)); assertEquals(4, NumberTheory.countTrailingZeros((byte) 0b00010000)); assertEquals(1, NumberTheory.countTrailingZeros((byte) 0b10101010)); } |
NumberTheory { static BigInteger[] factor(BigInteger number) throws FPEException { BigInteger n = number; BigInteger a = BigInteger.valueOf(1); BigInteger b = BigInteger.valueOf(1); int nLowZero = countLowZeroBits(n); a = a.shiftLeft(nLowZero / 2); b = b.shiftLeft(nLowZero - (nLowZero / 2)); n = n.shiftRight(nLowZero); for (int i = 0; i != PRIMES_BI.length; i++) { while (n.mod(PRIMES_BI[i]).signum() == 0) { a = a.multiply(PRIMES_BI[i]); if (a.compareTo(b) == 1) { BigInteger t = a; a = b; b = t; } n = n.divide(PRIMES_BI[i]); } } if (a.compareTo(b) == 1) { BigInteger t = a; a = b; b = t; } a = a.multiply(n); if (a.compareTo(b) == -1) { BigInteger t = a; a = b; b = t; } if ((a.compareTo(BigInteger.ONE) <= 0) || (b.compareTo(BigInteger.ONE) <= 0)) { throw new FPEException("Could not factor passed number for use in FPE. This is usually caused by passing a prime number for a modulus."); } return new BigInteger[] { a, b }; } private NumberTheory(); } | @Test public void testFactor() throws FPEException { assertArrayEquals(this.cfp(3, 3), NumberTheory.factor(BigInteger.valueOf(9))); assertArrayEquals(this.cfp(6, 2), NumberTheory.factor(BigInteger.valueOf(12))); assertArrayEquals(this.cfp(6, 2), NumberTheory.factor(BigInteger.valueOf(12))); assertArrayEquals(this.cfp(16, 8), NumberTheory.factor(BigInteger.valueOf(128))); assertArrayEquals(this.cfp(43, 2), NumberTheory.factor(BigInteger.valueOf(86))); assertArrayEquals(this.cfp(19207, 2), NumberTheory.factor(BigInteger.valueOf(38414))); assertArrayEquals(this.cfp(1000, 1000), NumberTheory.factor(BigInteger.valueOf(1000000))); } |
Utility { public static byte[] reverse(byte[] source) { int len = source.length; byte[] destination = new byte[len]; for (int i = 0; i < len; i++) { destination[len - i - 1] = source[i]; } return destination; } private Utility(); static byte[] reverse(byte[] source); static byte[] toLEBytes(int i); } | @Test public void testReverse() { assertArrayEquals(new byte[0], Utility.reverse(new byte[0])); assertArrayEquals(TestUtility.cba(0xCA, 0xFE, 0xBA, 0xBE), Utility.reverse(TestUtility.cba(0xBE, 0xBA, 0xFE, 0xCA))); assertArrayEquals(TestUtility.cba(0xCA), Utility.reverse(TestUtility.cba(0xCA))); } |
RoutersService { public void put(final RouterMeta routerMeta) { final JsonEventToLogger event = new JsonEventToLogger(this.getClass()); String logCorrelation = routerMeta.correlation; event.put("correlation", logCorrelation); try { String key = MessageFormat.format(FORMAT_KEY_ROUTERS, routerMeta.envId, routerMeta.groupId, routerMeta.localIP); registerRouterAndUpdateTtl(routerMeta, event, key); final Set<Long> eTagRouters = processEtagsFromRouters(routerMeta); updateRouterMapCached(routerMeta, eTagRouters); } catch (Exception e) { event.put("short_message", "POST /routers/" + routerMeta.envId + " FAILED"); event.sendError(e); } } @Autowired RoutersService(StringRedisTemplate redisTemplate, ChangesService changesService,
VersionService versionService, ConverterV1 converterV1, ConverterV2 converterV2,
EntityManagerFactory entityManagerFactory, LockerService lockerService); Set<JsonSchema.Env> get(); @SuppressWarnings("Duplicates") Set<JsonSchema.Env> get(String environmentId); int get(String envid, String routerGroupId); void put(final RouterMeta routerMeta); } | @Test @Rollback(false) public void shouldClearChangesWithNewestVersion() { RouterMeta routerMeta = new RouterMeta(); routerMeta.groupId = "group-local"; routerMeta.localIP = "127.0.0.1"; routerMeta.version = "2"; routerMeta.envId = "1"; routerMeta.zoneId = null; String versionOldest = "1"; Environment env; Target target; env = new Environment(); env.setId(Long.valueOf("1")); env.setName("env-name"); entityManager.persist(env); BalancePolicy bp = new BalancePolicy(); bp.setName("name-bp"); entityManager.persist(bp); Project project = new Project(); project.setName("name-project"); entityManager.persist(project); Pool pool = new Pool(); pool.setName("name-pool"); pool.setBalancepolicy(bp); pool.setEnvironment(env); pool.setProject(project); entityManager.persist(pool); target = new Target(); target.setLastModifiedAt(new Date()); target.setName("target-name"); target.setPool(pool); entityManager.persist(target); changesService.register(env, target, versionOldest); routersService.put(routerMeta); entityManager.clear(); boolean hasChanges = changesService.hasByEnvironmentId(Long.valueOf(routerMeta.envId)); Assert.assertFalse(hasChanges); Target t = entityManager.find(Target.class, 1L); Assert.assertNull(t); }
@Test public void shouldNotClearChangesWithOldestVersion() { RouterMeta routerMeta = new RouterMeta(); routerMeta.groupId = "group-local"; routerMeta.localIP = "127.0.0.1"; routerMeta.version = "1"; String versionNewest = "2"; routerMeta.envId = "1"; routerMeta.zoneId = null; Environment env = new Environment(); env.setId(Long.valueOf(routerMeta.envId)); Target target = new Target(); target.setId(999L); target.setLastModifiedAt(new Date()); changesService.register(env, target, versionNewest); routersService.put(routerMeta); boolean hasChanges = changesService.hasByEnvironmentId(Long.valueOf(routerMeta.envId)); Assert.assertTrue(hasChanges); } |
HealthMeterRegistry extends SimpleMeterRegistry { public static Builder builder(HealthConfig config) { return new Builder(config); } protected HealthMeterRegistry(HealthConfig config, Collection<ServiceLevelObjective> serviceLevelObjectives,
Collection<MeterFilter> serviceLevelObjectiveFilters,
Clock clock, ThreadFactory threadFactory); static Builder builder(HealthConfig config); Collection<ServiceLevelObjective> getServiceLevelObjectives(); void start(ThreadFactory threadFactory); void stop(); @Override void close(); } | @Test void onlyMetricsThatAreServiceLevelIndicatorsAreRegistered() { HealthMeterRegistry registry = HealthMeterRegistry.builder(HealthConfig.DEFAULT) .clock(new MockClock()) .serviceLevelObjectives( ServiceLevelObjective .build("counter.throughput") .count(search -> search.name("my.counter")) .isGreaterThan(1) ) .build(); assertThat(registry.getMeters()).isEmpty(); registry.counter("my.counter", "k", "v").increment(); assertThat(registry.getMeters().size()).isEqualTo(1); registry.counter("another.counter").increment(); assertThat(registry.getMeters().size()).isEqualTo(1); }
@Test void applyRequiredBinders() { HealthMeterRegistry registry = HealthMeterRegistry.builder(HealthConfig.DEFAULT) .clock(new MockClock()) .serviceLevelObjectives( ServiceLevelObjective .build("counter.throughput") .requires(new JvmMemoryMetrics()) .value(search -> search.name("jvm.memory.used")) .isGreaterThan(1) ) .build(); assertThat(registry.getMeters().stream().map(m -> m.getId().getName())) .containsOnly("jvm.memory.used") .isNotEmpty(); } |
PrometheusMeterRegistry extends MeterRegistry { public String scrape() { Writer writer = new StringWriter(); try { scrape(writer); } catch (IOException e) { throw new RuntimeException(e); } return writer.toString(); } PrometheusMeterRegistry(PrometheusConfig config); PrometheusMeterRegistry(PrometheusConfig config, CollectorRegistry registry, Clock clock); String scrape(); void scrape(Writer writer); @Override Counter newCounter(Meter.Id id); @Override DistributionSummary newDistributionSummary(Meter.Id id, DistributionStatisticConfig distributionStatisticConfig, double scale); CollectorRegistry getPrometheusRegistry(); PrometheusMeterRegistry throwExceptionOnRegistrationFailure(); } | @Issue("#61") @Test void timersRecordMax() { Timer timer = registry.timer("my.timer"); timer.record(10, TimeUnit.MILLISECONDS); timer.record(1, TimeUnit.SECONDS); assertThat(timer.max(TimeUnit.SECONDS)).isEqualTo(1); assertThat(timer.max(TimeUnit.MILLISECONDS)).isEqualTo(1000); assertThat(registry.scrape()).contains("my_timer_duration_seconds_max 1.0"); clock(registry).add(Duration.ofMillis(PrometheusConfig.DEFAULT.step().toMillis() * bufferLength())); assertThat(timer.max(TimeUnit.SECONDS)).isEqualTo(0); assertThat(registry.scrape()).contains("my_timer_duration_seconds_max 0.0"); }
@Issue("#61") @Test void distributionSummariesRecordMax() { DistributionSummary summary = registry.summary("my.summary"); summary.record(10); summary.record(1); assertThat(summary.max()).isEqualTo(10); assertThat(registry.scrape()).contains("my_summary_max 10.0"); clock(registry).add(PrometheusConfig.DEFAULT.step().toMillis() * bufferLength(), TimeUnit.MILLISECONDS); assertThat(summary.max()).isEqualTo(0); assertThat(registry.scrape()).contains("my_summary_max 0.0"); }
@Issue("#246") @Test void functionCounterNamingConvention() { FunctionCounter.builder("api.requests", 1.0, n -> n).register(registry); assertThat(registry.scrape()) .contains("api_requests_total 1.0"); }
@Issue("#519") @Test void timersMultipleMetrics() { Timer timer = registry.timer("my.timer"); timer.record(10, TimeUnit.MILLISECONDS); timer.record(20, TimeUnit.SECONDS); String scraped = registry.scrape(); assertThat(scraped).contains("# TYPE my_timer_duration_seconds_max gauge"); assertThat(scraped).contains("my_timer_duration_seconds_max 20.0"); assertThat(scraped).contains("# TYPE my_timer_duration_seconds summary"); assertThat(scraped).contains("my_timer_duration_seconds_count 2.0"); assertThat(scraped).contains("my_timer_duration_seconds_sum 20.01"); }
@Issue("#519") @Test void distributionSummariesMultipleMetrics() { DistributionSummary summary = registry.summary("my.summary"); summary.record(20); summary.record(1); String scraped = registry.scrape(); assertThat(scraped).contains("# TYPE my_summary_max gauge"); assertThat(scraped).contains("my_summary_max 20.0"); assertThat(scraped).contains("# TYPE my_summary summary"); assertThat(scraped).contains("my_summary_count 2.0"); assertThat(scraped).contains("my_summary_sum 21.0"); }
@Issue("#519") @Test void containsJustOneTypeHelpComment() { Timer timer1 = registry.timer("my.timer", "tag", "value1"); Timer timer2 = registry.timer("my.timer", "tag", "value2"); timer1.record(10, TimeUnit.MILLISECONDS); timer2.record(1, TimeUnit.SECONDS); String scraped = registry.scrape(); assertThat(scraped).containsOnlyOnce("# TYPE my_timer_duration_seconds_max gauge"); assertThat(scraped).containsOnlyOnce("# HELP my_timer_duration_seconds_max"); assertThat(scraped).containsOnlyOnce("# TYPE my_timer_duration_seconds summary"); assertThat(scraped).containsOnlyOnce("# HELP my_timer_duration_seconds "); }
@Test void scrapeWithLongTaskTimer() { LongTaskTimer.builder("my.long.task.timer").register(registry); assertThat(registry.scrape()) .contains("my_long_task_timer_duration_seconds_max") .contains("my_long_task_timer_duration_seconds_active_count") .contains("my_long_task_timer_duration_seconds_duration_sum"); }
@Test void baseUnitMakesItToScrape() { AtomicInteger n = new AtomicInteger(0); Gauge.builder("gauge", n, AtomicInteger::get).tags("a", "b").baseUnit(BaseUnits.BYTES).register(registry); assertThat(registry.scrape()).contains("gauge_bytes"); }
@DisplayName("description text is bound to 'help' on Prometheus collectors") @Test void helpText() { Timer.builder("timer").description("my timer").register(registry); Counter.builder("counter").description("my counter").register(registry); DistributionSummary.builder("summary").description("my summary").register(registry); Gauge.builder("gauge", new AtomicInteger(), AtomicInteger::doubleValue).description("my gauge").register(registry); LongTaskTimer.builder("long.task.timer").description("my long task timer").register(registry); assertThat(registry.scrape()) .contains("HELP timer_duration_seconds my timer") .contains("HELP summary my summary") .contains("HELP gauge my gauge") .contains("HELP counter_total my counter") .contains("HELP long_task_timer_duration_seconds my long task timer"); }
@Issue("#249") @Test void type() { Timer.builder("t1").register(registry); Timer.builder("t2").publishPercentileHistogram().register(registry); assertThat(registry.scrape()) .contains("# TYPE t1_duration_seconds summary") .contains("# TYPE t2_duration_seconds histogram"); }
@Test void namingConventionOfCustomMeters() { CompositeMeterRegistry composite = new CompositeMeterRegistry(); composite.add(registry); registry.more().counter("my.custom", emptyList(), 0); assertThat(registry.scrape()) .contains("my_custom"); }
@Test void percentileTimersContainPositiveInfinity() { Timer timer = Timer.builder("my.timer").publishPercentileHistogram().register(registry); timer.record(1, TimeUnit.MILLISECONDS); assertThat(registry.scrape()).contains("le=\"+Inf\""); }
@Test void percentileTimersAreClampedByDefault() { Timer timer = Timer.builder("my.timer") .publishPercentileHistogram() .register(registry); timer.record(1, TimeUnit.MILLISECONDS); assertThat(Arrays.stream(registry.scrape().split("\n")).filter(l -> l.contains("le="))) .hasSize(69); }
@Issue("#127") @Test void percentileHistogramsAccumulateToInfinityEvenWhenClamped() { Timer t = Timer.builder("t1") .publishPercentileHistogram() .register(registry); t.record(106, TimeUnit.SECONDS); assertThat(registry.scrape()) .contains("t1_duration_seconds_bucket{le=\"+Inf\",} 1.0"); }
@Issue("#265") @Test void percentileHistogramsNeverResetForTimers() { Timer t = Timer.builder("t1") .publishPercentileHistogram() .distributionStatisticExpiry(Duration.ofSeconds(60)) .serviceLevelObjectives(Duration.ofMillis(100)) .register(registry); t.record(100, TimeUnit.MILLISECONDS); clock.addSeconds(60); assertThat(registry.scrape()) .contains("t1_duration_seconds_bucket{le=\"0.1\",} 1.0"); }
@Issue("#265") @Test void percentileHistogramsNeverResetForSummaries() { DistributionSummary s = DistributionSummary.builder("s1") .publishPercentileHistogram() .distributionStatisticExpiry(Duration.ofSeconds(60)) .serviceLevelObjectives(100.0) .register(registry); s.record(100); clock.addSeconds(60); assertThat(registry.scrape()) .contains("s1_bucket{le=\"100.0\",} 1.0"); }
@Issue("#247") @Test void distributionPercentileBuckets() { DistributionSummary ds = DistributionSummary.builder("ds") .publishPercentileHistogram() .minimumExpectedValue(1.0) .maximumExpectedValue(2100.0) .register(registry); ds.record(30); ds.record(9); ds.record(62); assertThat(registry.scrape()) .contains("ds_bucket{le=\"1.0\",}") .contains("ds_bucket{le=\"2100.0\",} 3.0"); }
@Issue("#127") @Test void percentileHistogramsWhenValueIsLessThanTheSmallestBucket() { DistributionSummary speedIndexRatings = DistributionSummary.builder("speed.index") .tags("page", "home") .description("Distribution of 'speed index' ratings") .publishPercentileHistogram() .register(registry); speedIndexRatings.record(0); assertThat(registry.scrape()).contains("speed_index_bucket{page=\"home\",le=\"+Inf\",} 1.0"); }
@Issue("#370") @Test void serviceLevelObjectivesOnlyNoPercentileHistogram() { DistributionSummary.builder("my.summary").serviceLevelObjectives(1.0).register(registry).record(1); assertThat(registry.scrape()).contains("my_summary_bucket{le=\"1.0\",} 1.0"); Timer.builder("my.timer").serviceLevelObjectives(Duration.ofMillis(1)).register(registry).record(1, TimeUnit.MILLISECONDS); assertThat(registry.scrape()).contains("my_timer_duration_seconds_bucket{le=\"0.001\",} 1.0"); } |
PrometheusNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { String conventionName = NamingConvention.snakeCase.name(name, type, baseUnit); switch (type) { case COUNTER: case DISTRIBUTION_SUMMARY: case GAUGE: if (baseUnit != null && !conventionName.endsWith("_" + baseUnit)) conventionName += "_" + baseUnit; break; } switch (type) { case COUNTER: if (!conventionName.endsWith("_total")) conventionName += "_total"; break; case TIMER: case LONG_TASK_TIMER: if (conventionName.endsWith(timerSuffix)) { conventionName += "_seconds"; } else if (!conventionName.endsWith("_seconds")) conventionName += timerSuffix + "_seconds"; break; } String sanitized = nameChars.matcher(conventionName).replaceAll("_"); if (!Character.isLetter(sanitized.charAt(0))) { sanitized = "m_" + sanitized; } return sanitized; } PrometheusNamingConvention(); PrometheusNamingConvention(String timerSuffix); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); } | @Test void formatName() { assertThat(convention.name("123abc/{:id}水", Meter.Type.GAUGE)).startsWith("m_123abc__:id__"); }
@Test void unitsAreAppendedToTimers() { assertThat(convention.name("timer", Meter.Type.TIMER)).isEqualTo("timer_seconds"); assertThat(convention.name("timer", Meter.Type.LONG_TASK_TIMER)).isEqualTo("timer_seconds"); assertThat(convention.name("timer.duration", Meter.Type.LONG_TASK_TIMER)).isEqualTo("timer_duration_seconds"); }
@Test void unitsAreAppendedToDistributionSummaries() { assertThat(convention.name("response.size", Meter.Type.DISTRIBUTION_SUMMARY, BaseUnits.BYTES)).isEqualTo("response_size_bytes"); assertThat(convention.name("summary", Meter.Type.DISTRIBUTION_SUMMARY)).isEqualTo("summary"); }
@Test void unitsAreAppendedToCounters() { assertThat(convention.name("response.size", Meter.Type.COUNTER, BaseUnits.BYTES)).isEqualTo("response_size_bytes_total"); assertThat(convention.name("counter", Meter.Type.COUNTER)).isEqualTo("counter_total"); }
@Test void unitsAreAppendedToGauges() { assertThat(convention.name("response.size", Meter.Type.GAUGE, BaseUnits.BYTES)).isEqualTo("response_size_bytes"); assertThat(convention.name("gauge", Meter.Type.GAUGE)).isEqualTo("gauge"); }
@Test void dotNotationIsConvertedToSnakeCase() { assertThat(convention.name("gauge.size", Meter.Type.GAUGE)).isEqualTo("gauge_size"); } |
PrometheusNamingConvention implements NamingConvention { @Override public String tagKey(String key) { String conventionKey = NamingConvention.snakeCase.tagKey(key); String sanitized = tagKeyChars.matcher(conventionKey).replaceAll("_"); if (!Character.isLetter(sanitized.charAt(0))) { sanitized = "m_" + sanitized; } return sanitized; } PrometheusNamingConvention(); PrometheusNamingConvention(String timerSuffix); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); } | @Test void formatTagKey() { assertThat(convention.tagKey("123abc/{:id}水")).startsWith("m_123abc___id__"); } |
NewRelicMeterRegistry extends StepMeterRegistry { @Override public Config config() { return thisConfig; } NewRelicMeterRegistry(NewRelicConfig config, Clock clock); NewRelicMeterRegistry(NewRelicConfig config, @Nullable NewRelicClientProvider clientProvider, Clock clock); NewRelicMeterRegistry(NewRelicConfig config, @Nullable NewRelicClientProvider clientProvider,
NamingConvention namingConvention, Clock clock, ThreadFactory threadFactory); @Override Config config(); static Builder builder(NewRelicConfig config); } | @Test void succeedsConfigInsightsAgentClientProviderAndCustomNamingConvention() { NamingConvention customNamingConvention = mock(NewRelicNamingConvention.class); NewRelicMeterRegistry registry = new NewRelicMeterRegistry(insightsAgentConfig, null, customNamingConvention, clock, new NamedThreadFactory("new-relic-test")); assertThat(registry.clientProvider).isInstanceOf(NewRelicInsightsAgentClientProvider.class); assertThat(((NewRelicInsightsAgentClientProvider) registry.clientProvider).namingConvention) .isSameAs(customNamingConvention); assertThat(registry.config().namingConvention()).isSameAs(customNamingConvention); }
@Test void succeedsConfigInsightsApiClientProviderAndDefaultNamingConvention() { NewRelicMeterRegistry registry = new NewRelicMeterRegistry(insightsApiConfig, null, clock); assertThat(registry.clientProvider).isInstanceOf(NewRelicInsightsApiClientProvider.class); assertThat(((NewRelicInsightsApiClientProvider) registry.clientProvider).namingConvention) .isInstanceOf(NewRelicNamingConvention.class); assertThat(registry.config().namingConvention()).isInstanceOf(NewRelicNamingConvention.class); }
@Test void succeedsConfigInsightsApiClientProviderAndCustomNamingConvention() { NamingConvention customNamingConvention = mock(NewRelicNamingConvention.class); NewRelicMeterRegistry registry = new NewRelicMeterRegistry(insightsApiConfig, null, customNamingConvention, clock, new NamedThreadFactory("new-relic-test")); assertThat(registry.clientProvider).isInstanceOf(NewRelicInsightsApiClientProvider.class); assertThat(((NewRelicInsightsApiClientProvider) registry.clientProvider).namingConvention) .isSameAs(customNamingConvention); assertThat(registry.config().namingConvention()).isSameAs(customNamingConvention); }
@Test void succeedsConfigInsightsAgentClientProviderAndDefaultNamingConvention() { NewRelicMeterRegistry registry = new NewRelicMeterRegistry(insightsAgentConfig, null, clock); assertThat(registry.clientProvider).isInstanceOf(NewRelicInsightsAgentClientProvider.class); assertThat(((NewRelicInsightsAgentClientProvider) registry.clientProvider).namingConvention) .isInstanceOf(NewRelicNamingConvention.class); assertThat(registry.config().namingConvention()).isInstanceOf(NewRelicNamingConvention.class); } |
KairosMeterRegistry extends StepMeterRegistry { Stream<String> writeGauge(Gauge gauge) { double value = gauge.value(); if (Double.isFinite(value)) { return Stream.of(writeMetric(gauge.getId(), config().clock().wallTime(), value)); } return Stream.empty(); } @SuppressWarnings("deprecation") KairosMeterRegistry(KairosConfig config, Clock clock); private KairosMeterRegistry(KairosConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(KairosConfig config); } | @Test void writeGauge() { meterRegistry.gauge("my.gauge", 1d); Gauge gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).hasSize(1); }
@Test void writeGaugeShouldDropNanValue() { meterRegistry.gauge("my.gauge", Double.NaN); Gauge gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); }
@Test void writeGaugeShouldDropInfiniteValues() { meterRegistry.gauge("my.gauge", Double.POSITIVE_INFINITY); Gauge gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); meterRegistry.gauge("my.gauge", Double.NEGATIVE_INFINITY); gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); } |
KairosMeterRegistry extends StepMeterRegistry { Stream<String> writeTimeGauge(TimeGauge timeGauge) { double value = timeGauge.value(getBaseTimeUnit()); if (Double.isFinite(value)) { return Stream.of(writeMetric(timeGauge.getId(), config().clock().wallTime(), value)); } return Stream.empty(); } @SuppressWarnings("deprecation") KairosMeterRegistry(KairosConfig config, Clock clock); private KairosMeterRegistry(KairosConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(KairosConfig config); } | @Test void writeTimeGauge() { AtomicReference<Double> obj = new AtomicReference<>(1d); meterRegistry.more().timeGauge("my.timeGauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); TimeGauge timeGauge = meterRegistry.find("my.timeGauge").timeGauge(); assertThat(meterRegistry.writeTimeGauge(timeGauge)).hasSize(1); }
@Test void writeTimeGaugeShouldDropNanValue() { AtomicReference<Double> obj = new AtomicReference<>(Double.NaN); meterRegistry.more().timeGauge("my.timeGauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); TimeGauge timeGauge = meterRegistry.find("my.timeGauge").timeGauge(); assertThat(meterRegistry.writeTimeGauge(timeGauge)).isEmpty(); }
@Test void writeTimeGaugeShouldDropInfiniteValues() { AtomicReference<Double> obj = new AtomicReference<>(Double.POSITIVE_INFINITY); meterRegistry.more().timeGauge("my.timeGauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); TimeGauge timeGauge = meterRegistry.find("my.timeGauge").timeGauge(); assertThat(meterRegistry.writeTimeGauge(timeGauge)).isEmpty(); obj = new AtomicReference<>(Double.NEGATIVE_INFINITY); meterRegistry.more().timeGauge("my.timeGauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); timeGauge = meterRegistry.find("my.timeGauge").timeGauge(); assertThat(meterRegistry.writeTimeGauge(timeGauge)).isEmpty(); } |
NewRelicMeterRegistry extends StepMeterRegistry { public static Builder builder(NewRelicConfig config) { return new Builder(config); } NewRelicMeterRegistry(NewRelicConfig config, Clock clock); NewRelicMeterRegistry(NewRelicConfig config, @Nullable NewRelicClientProvider clientProvider, Clock clock); NewRelicMeterRegistry(NewRelicConfig config, @Nullable NewRelicClientProvider clientProvider,
NamingConvention namingConvention, Clock clock, ThreadFactory threadFactory); @Override Config config(); static Builder builder(NewRelicConfig config); } | @SuppressWarnings("deprecation") @Test void canCustomizeHttpSenderViaBuilder_deprecated() { HttpSender httpSender = mock(HttpSender.class); NewRelicClientProvider clientProvider = NewRelicMeterRegistry.builder(insightsApiConfig).httpClient(httpSender).build().clientProvider; assertThat(clientProvider).isInstanceOf(NewRelicInsightsApiClientProvider.class); assertThat(((NewRelicInsightsApiClientProvider) clientProvider).httpClient).isEqualTo(httpSender); }
@Test void canCustomizeHttpSenderViaBuilder() { HttpSender httpSender = mock(HttpSender.class); NewRelicClientProvider clientProvider = NewRelicMeterRegistry.builder(insightsApiConfig) .clientProvider(new NewRelicInsightsApiClientProvider(insightsApiConfig, httpSender, new NewRelicNamingConvention())) .build().clientProvider; assertThat(clientProvider).isInstanceOf(NewRelicInsightsApiClientProvider.class); assertThat(((NewRelicInsightsApiClientProvider) clientProvider).httpClient).isEqualTo(httpSender); }
@Test void writeCounterWithFunctionCounter() { FunctionCounter counter = FunctionCounter.builder("myCounter", 1d, Number::doubleValue).register(registry); clock.add(insightsApiConfig.step()); writeCounterWithFunctionCounter(counter, getInsightsApiClientProvider(meterNameEventTypeEnabledConfig), "{\"eventType\":\"myCounter\",\"throughput\":1}"); writeCounterWithFunctionCounter(counter, getInsightsApiClientProvider(insightsApiConfig), "{\"eventType\":\"MicrometerSample\",\"throughput\":1,\"metricName\":\"myCounter\",\"metricType\":\"COUNTER\"}"); Map<String, Object> expectedEntries = new HashMap<>(); expectedEntries.put("throughput", 1); writeCounterWithFunctionCounter(counter, getInsightsAgentClientProvider(meterNameEventTypeEnabledConfig), expectedEntries); expectedEntries.put("metricName", "myCounter"); expectedEntries.put("metricType", "COUNTER"); writeCounterWithFunctionCounter(counter, getInsightsAgentClientProvider(insightsAgentConfig), expectedEntries); }
@Test void writeMeterWhenCustomMeterHasDuplicatesKeysShouldWriteOnlyLastValue() { Measurement measurement1 = new Measurement(() -> 3d, Statistic.VALUE); Measurement measurement2 = new Measurement(() -> 1d, Statistic.VALUE); Measurement measurement3 = new Measurement(() -> 2d, Statistic.VALUE); List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3); Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.registry); assertThat(getInsightsApiClientProvider(insightsApiConfig).writeMeter(meter)).containsExactly( "{\"eventType\":\"MicrometerSample\",\"value\":2,\"metricName\":\"myMeter\",\"metricType\":\"GAUGE\"}"); Map<String, Object> expectedEntries = new HashMap<>(); expectedEntries.put("value", 2); expectedEntries.put("metricName", "myMeter"); expectedEntries.put("metricType", "GAUGE"); assertThat(getInsightsAgentClientProvider(insightsAgentConfig).writeMeter(meter)).isEqualTo(expectedEntries); } |
KairosMeterRegistry extends StepMeterRegistry { Stream<String> writeFunctionCounter(FunctionCounter counter) { double count = counter.count(); if (Double.isFinite(count)) { return Stream.of(writeMetric(counter.getId(), config().clock().wallTime(), count)); } return Stream.empty(); } @SuppressWarnings("deprecation") KairosMeterRegistry(KairosConfig config, Clock clock); private KairosMeterRegistry(KairosConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(KairosConfig config); } | @Test void writeFunctionCounter() { FunctionCounter counter = FunctionCounter.builder("myCounter", 1d, Number::doubleValue).register(meterRegistry); clock.add(config.step()); assertThat(meterRegistry.writeFunctionCounter(counter)).hasSize(1); } |
KairosNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return format(delegate.name(name, type, baseUnit)); } KairosNamingConvention(); KairosNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void defaultToSnakeCase() { assertThat(convention.name("gauge.size", Meter.Type.GAUGE)).isEqualTo("gauge_size"); } |
SysdigStatsdLineBuilder extends FlavorStatsdLineBuilder { @Override String line(String amount, @Nullable Statistic stat, String type) { updateIfNamingConventionChanged(); return name + tagsByStatistic(stat) + ":" + amount + "|" + type; } SysdigStatsdLineBuilder(Meter.Id id, MeterRegistry.Config config); } | @Test void changingNamingConvention() { Counter c = registry.counter("my.counter", "my.tag", "value"); SysdigStatsdLineBuilder lb = new SysdigStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my.counter#statistic=count,my.tag=value:1|c"); registry.config().namingConvention(NamingConvention.camelCase); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("myCounter#statistic=count,myTag=value:1|c"); }
@Issue("#739") @Test void sanitizeColons() { Counter c = registry.counter("my:counter", "my:tag", "my:value"); SysdigStatsdLineBuilder lb = new SysdigStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my_counter#statistic=count,my_tag=my_value:1|c"); }
@Issue("#970") @Test void sanitizeAllNonAlphaNumericCharacters() { String badCounterName = "\"\';^*()!~`_./?a{counter}:with123 weirdChars"; String badTagName = "\"\';^*()!~`_./?a{tag}:with123 weirdChars"; String badValueName = "\"\';^*()!~`_./?a{value}:with123 weirdChars"; Counter c = registry.counter(badCounterName, badTagName, badValueName); SysdigStatsdLineBuilder lb = new SysdigStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); StringBuilder expected = new StringBuilder(); expected.append("___________.__a_counter__with123_weirdChars") .append("#statistic=count,___________.__a_tag__with123_weirdChars") .append("=___________.__a_value__with123_weirdChars:1|c"); assertThat(lb.line("1", Statistic.COUNT, "c")) .isEqualTo(expected.toString()); } |
BufferingFlux { public static Flux<String> create(final Flux<String> source, final String delimiter, final int maxByteArraySize, final long maxMillisecondsBetweenEmits) { return Flux.defer(() -> { final int delimiterSize = delimiter.getBytes().length; final AtomicInteger byteSize = new AtomicInteger(0); final AtomicLong lastTime = new AtomicLong(0); final DirectProcessor<Void> intervalEnd = DirectProcessor.create(); final Flux<String> heartbeat = Flux.interval(Duration.ofMillis(maxMillisecondsBetweenEmits)) .map(l -> "") .takeUntilOther(intervalEnd); final Flux<String> sourceWithEmptyStringKeepAlive = source .doOnTerminate(intervalEnd::onComplete) .mergeWith(heartbeat); return sourceWithEmptyStringKeepAlive .bufferUntil(line -> { final int bytesLength = line.getBytes().length; final long now = System.currentTimeMillis(); lastTime.compareAndSet(0, now); final long last = lastTime.get(); long diff; if (last != 0L) { diff = now - last; if (diff > maxMillisecondsBetweenEmits && byteSize.get() > 0) { byteSize.set(bytesLength); lastTime.compareAndSet(last, now); return true; } } int additionalBytes = bytesLength; if (additionalBytes > 0 && byteSize.get() > 0) { additionalBytes += delimiterSize; } final int projectedBytes = byteSize.addAndGet(additionalBytes); if (projectedBytes > maxByteArraySize) { byteSize.set(bytesLength); lastTime.compareAndSet(last, now); return true; } return false; }, true) .map(lines -> lines.stream() .filter(line -> !line.isEmpty()) .collect(Collectors.joining(delimiter, "", delimiter))); }); } private BufferingFlux(); static Flux<String> create(final Flux<String> source, final String delimiter, final int maxByteArraySize, final long maxMillisecondsBetweenEmits); } | @Test void bufferSingleStrings() { Flux<String> source = Flux.just( "twelve bytes", "fourteen bytes", "twelve bytes", "fourteen bytes" ).delayElements(Duration.ofMillis(50)); Flux<String> buffered = BufferingFlux.create(source, "\n", 14, 200); StepVerifier.create(buffered) .expectNext("twelve bytes\n") .expectNext("fourteen bytes\n") .expectNext("twelve bytes\n") .expectNext("fourteen bytes\n") .verifyComplete(); }
@Test void bufferMultipleStrings() { Flux<String> source = Flux.just( "twelve bytes", "fourteen bytes", "twelve bytes", "fourteen bytes" ); Flux<String> buffered = BufferingFlux.create(source, "\n", 27, Long.MAX_VALUE); StepVerifier.create(buffered) .expectNext("twelve bytes\nfourteen bytes\n") .expectNext("twelve bytes\nfourteen bytes\n") .verifyComplete(); }
@Test void bufferUntilTimeout() { Flux<String> source = Flux.concat( Mono.just("twelve bytes"), Mono.just("fourteen bytes"), Mono.just("twelve bytes"), Mono.just("fourteen bytes").delayElement(Duration.ofMillis(65)) ); Flux<String> buffered = BufferingFlux.create(source, "\n", Integer.MAX_VALUE, 50); StepVerifier.create(buffered) .expectNext("twelve bytes\nfourteen bytes\ntwelve bytes\n") .expectNext("fourteen bytes\n") .verifyComplete(); }
@Test void doNotBufferIndefinitely() throws InterruptedException { Flux<String> source = Flux.interval(Duration.ofMillis(100)) .map(Object::toString); Flux<String> buffered = BufferingFlux.create(source, "\n", Integer.MAX_VALUE, 200); CountDownLatch received = new CountDownLatch(1); buffered.subscribe(v -> received.countDown()); received.await(10, TimeUnit.SECONDS); }
@Test void bufferMessagesCanBeAppended() throws InterruptedException { int numberOfLines = 500; List<String> stats = new ArrayList<>(); IntStream.range(0, numberOfLines).forEachOrdered(i -> stats.add("test.msg.example:" + i + "|c")); String[] lines = stats.toArray(new String[0]); Flux<String> source = Flux.just(lines) .delayElements(Duration.ofMillis(1)); Flux<String> buffered = BufferingFlux.create(source, "\n", 100, 10); CountDownLatch latch = new CountDownLatch(numberOfLines); StringBuilder sb = new StringBuilder(); buffered.subscribe((bufferedLines) -> { sb.append(bufferedLines); int numberOfBufferedLines = bufferedLines.split("\n").length; for (int i = 0; i < numberOfBufferedLines; i++) { latch.countDown(); } }); assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue(); String[] resultLines = sb.toString().split("\n"); assertThat(resultLines).isEqualTo(lines); } |
EtsyStatsdLineBuilder extends FlavorStatsdLineBuilder { @Override String line(String amount, @Nullable Statistic stat, String type) { updateIfNamingConventionChanged(); return nameByStatistic(stat) + ":" + amount + "|" + type; } EtsyStatsdLineBuilder(Meter.Id id, MeterRegistry.Config config, HierarchicalNameMapper nameMapper); } | @Test void changingNamingConvention() { Counter c = registry.counter("my.counter", "my.tag", "value"); EtsyStatsdLineBuilder lb = new EtsyStatsdLineBuilder(c.getId(), registry.config(), HierarchicalNameMapper.DEFAULT); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my.counter.my.tag.value.statistic.count:1|c"); registry.config().namingConvention(NamingConvention.camelCase); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("myCounter.myTag.value.statistic.count:1|c"); }
@Issue("#739") @Test void sanitizeColons() { Counter c = registry.counter("my:counter", "my:tag", "my:value"); EtsyStatsdLineBuilder lb = new EtsyStatsdLineBuilder(c.getId(), registry.config(), HierarchicalNameMapper.DEFAULT); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my_counter.my_tag.my_value.statistic.count:1|c"); } |
DatadogStatsdLineBuilder extends FlavorStatsdLineBuilder { @Override String line(String amount, @Nullable Statistic stat, String type) { updateIfNamingConventionChanged(); return name + amount + "|" + type + tagsByStatistic(stat); } DatadogStatsdLineBuilder(Meter.Id id, MeterRegistry.Config config); } | @Test void changingNamingConvention() { Counter c = registry.counter("my.counter", "my.tag", "value"); DatadogStatsdLineBuilder lb = new DatadogStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my.counter:1|c|#statistic:count,my.tag:value"); registry.config().namingConvention(NamingConvention.camelCase); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("myCounter:1|c|#statistic:count,myTag:value"); }
@Issue("#739") @Test void sanitizeColonsInTagKeys() { Counter c = registry.counter("my:counter", "my:tag", "my_value"); DatadogStatsdLineBuilder lb = new DatadogStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my_counter:1|c|#statistic:count,my_tag:my_value"); }
@Test void interpretEmptyTagValuesAsValuelessTags() { Counter c = registry.counter("my:counter", "my:tag", ""); DatadogStatsdLineBuilder lb = new DatadogStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my_counter:1|c|#statistic:count,my_tag"); }
@Issue("#1998") @Test void allowColonsInTagValues() { Counter c = registry.counter("my:counter", "my:tag", "my:value", "other_tag", "some:value:", "123.another.tag", "123:value"); DatadogStatsdLineBuilder lb = new DatadogStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")) .isEqualTo("my_counter:1|c|#statistic:count,m.123.another.tag:123:value,my_tag:my:value,other_tag:some:value_"); } |
TelegrafStatsdLineBuilder extends FlavorStatsdLineBuilder { @Override String line(String amount, @Nullable Statistic stat, String type) { updateIfNamingConventionChanged(); return name + tagsByStatistic(stat) + ":" + amount + "|" + type; } TelegrafStatsdLineBuilder(Meter.Id id, MeterRegistry.Config config); } | @Test void changingNamingConvention() { Counter c = registry.counter("my.counter", "my.tag", "value"); TelegrafStatsdLineBuilder lb = new TelegrafStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my.counter,statistic=count,my.tag=value:1|c"); registry.config().namingConvention(NamingConvention.camelCase); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("myCounter,statistic=count,myTag=value:1|c"); }
@Issue("#739") @Test void sanitizeColons() { Counter c = registry.counter("my:counter", "my:tag", "my:value"); TelegrafStatsdLineBuilder lb = new TelegrafStatsdLineBuilder(c.getId(), registry.config()); registry.config().namingConvention(NamingConvention.dot); assertThat(lb.line("1", Statistic.COUNT, "c")).isEqualTo("my_counter,statistic=count,my_tag=my_value:1|c"); } |
StatsdMeterRegistry extends MeterRegistry { public static Builder builder(StatsdConfig config) { return new Builder(config); } StatsdMeterRegistry(StatsdConfig config, Clock clock); StatsdMeterRegistry(StatsdConfig config, HierarchicalNameMapper nameMapper, Clock clock); private StatsdMeterRegistry(StatsdConfig config,
HierarchicalNameMapper nameMapper,
NamingConvention namingConvention,
Clock clock,
@Nullable Function<Meter.Id, StatsdLineBuilder> lineBuilderFunction,
@Nullable Consumer<String> lineSink); static Builder builder(StatsdConfig config); void start(); void stop(); @Override void close(); @Deprecated int queueSize(); @Deprecated int queueCapacity(); } | @Test void customNamingConvention() { final Processor<String, String> lines = lineProcessor(); registry = StatsdMeterRegistry.builder(configWithFlavor(StatsdFlavor.ETSY)) .nameMapper((id, convention) -> id.getName().toUpperCase()) .clock(clock) .lineSink(toSink(lines)) .build(); StepVerifier.create(lines) .then(() -> registry.counter("my.counter", "my.tag", "val").increment(2.1)) .expectNext("MY.COUNTER:2|c") .verifyComplete(); }
@Test void timersWithServiceLevelObjectivesHaveInfBucket() { registry = new StatsdMeterRegistry(configWithFlavor(StatsdFlavor.ETSY), clock); Timer.builder("my.timer").serviceLevelObjectives(Duration.ofMillis(1)).register(registry); registry.get("my.timer.histogram").tag("le", "+Inf").gauge(); }
@Test void distributionSummariesWithServiceLevelObjectivesHaveInfBucket() { registry = new StatsdMeterRegistry(configWithFlavor(StatsdFlavor.ETSY), clock); DistributionSummary summary = DistributionSummary.builder("my.distribution").serviceLevelObjectives(1.0).register(registry); registry.get("my.distribution.histogram").tag("le", "+Inf").gauge(); }
@Test void infBucketEqualsCount() { registry = new StatsdMeterRegistry(configWithFlavor(StatsdFlavor.ETSY), clock); Timer timer = Timer.builder("my.timer").serviceLevelObjectives(Duration.ofMillis(1)).register(registry); timer.record(1, TimeUnit.MILLISECONDS); Gauge timerHist = registry.get("my.timer.histogram").tags("le", "+Inf").gauge(); Long count = timer.takeSnapshot().count(); assertThat(timerHist.value()).isEqualTo(1); assertThat(count).isEqualTo(1); }
@Test @Issue("#1260") void lineSinkDoesNotConsumeWhenRegistryDisabled() { Consumer<String> shouldNotBeInvokedConsumer = line -> { throw new RuntimeException("line sink should not be called"); }; registry = StatsdMeterRegistry.builder(new StatsdConfig() { @Override public String get(String key) { return null; } @Override public boolean enabled() { return false; } }) .lineSink(shouldNotBeInvokedConsumer) .build(); registry.counter("some.metric").increment(); assertThat(registry.processor.inners().count()).as("processor has no subscribers registered").isZero(); } |
NewRelicNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return StringEscapeUtils.escapeJson(toValidNewRelicString(delegate.name(name, type, baseUnit))); } NewRelicNamingConvention(); NewRelicNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void name() { String validString = newRelicNamingConvention.name(VALID_NAME, Type.COUNTER); assertThat(validString).isEqualTo(VALID_NAME); }
@Test void nameShouldStripInvalidCharacters() { String validString = newRelicNamingConvention.name(INVALID_NAME, Type.COUNTER); assertThat(validString).isEqualTo("invalid_name"); } |
StatsdMeterRegistry extends MeterRegistry { public void stop() { if (started.compareAndSet(true, false)) { if (statsdConnection.get() != null) { statsdConnection.get().dispose(); } if (meterPoller.get() != null) { meterPoller.get().dispose(); } } } StatsdMeterRegistry(StatsdConfig config, Clock clock); StatsdMeterRegistry(StatsdConfig config, HierarchicalNameMapper nameMapper, Clock clock); private StatsdMeterRegistry(StatsdConfig config,
HierarchicalNameMapper nameMapper,
NamingConvention namingConvention,
Clock clock,
@Nullable Function<Meter.Id, StatsdLineBuilder> lineBuilderFunction,
@Nullable Consumer<String> lineSink); static Builder builder(StatsdConfig config); void start(); void stop(); @Override void close(); @Deprecated int queueSize(); @Deprecated int queueCapacity(); } | @Test void interactWithStoppedRegistry() { registry = new StatsdMeterRegistry(configWithFlavor(StatsdFlavor.ETSY), clock); registry.stop(); registry.counter("my.counter").increment(); } |
StatsdGauge extends AbstractMeter implements Gauge, StatsdPollable { @Override public void poll() { double val = value(); if (Double.isFinite(val) && (alwaysPublish || lastValue.getAndSet(val) != val)) { sink.next(lineBuilder.gauge(val)); } } StatsdGauge(Id id, StatsdLineBuilder lineBuilder, FluxSink<String> sink, @Nullable T obj, ToDoubleFunction<T> value, boolean alwaysPublish); @Override double value(); @Override void poll(); @SuppressWarnings("EqualsWhichDoesntCheckParameterClass") @Override boolean equals(Object o); @Override int hashCode(); } | @Test void shouldAlwaysPublishValue() { AtomicInteger lines = new AtomicInteger(0); MeterRegistry registry = StatsdMeterRegistry.builder(StatsdConfig.DEFAULT) .lineSink(l -> lines.incrementAndGet()) .build(); StatsdGauge<?> alwaysPublishingGauge = (StatsdGauge<?>) Gauge .builder("test", value, AtomicInteger::get).register(registry); alwaysPublishingGauge.poll(); alwaysPublishingGauge.poll(); assertThat(lines.get()).isEqualTo(2); }
@Test void shouldOnlyPublishValueWhenValueChanges() { AtomicInteger lines = new AtomicInteger(0); MeterRegistry registry = StatsdMeterRegistry .builder(new StatsdConfig() { @Override public String get(String key) { return null; } @Override public boolean publishUnchangedMeters() { return false; } }) .lineSink(l -> lines.incrementAndGet()) .build(); StatsdGauge<?> gaugePublishingOnChange = (StatsdGauge<?>) Gauge .builder("test", value, AtomicInteger::get).register(registry); gaugePublishingOnChange.poll(); gaugePublishingOnChange.poll(); assertThat(lines.get()).isEqualTo(1); value.incrementAndGet(); gaugePublishingOnChange.poll(); assertThat(lines.get()).isEqualTo(2); } |
InfluxNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return escape(delegate.name(name, type, baseUnit).replace("=", "_")); } InfluxNamingConvention(); InfluxNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Issue("#693") @Test void name() { assertThat(convention.name("foo.bar=, baz", Meter.Type.GAUGE)).isEqualTo("foo_bar_\\,\\ baz"); } |
InfluxNamingConvention implements NamingConvention { @Override public String tagKey(String key) { if (key.equals("time")) { throw new IllegalArgumentException("'time' is an invalid tag key in InfluxDB"); } return escape(delegate.tagKey(key)); } InfluxNamingConvention(); InfluxNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagKey() { assertThat(convention.tagKey("foo.bar=, baz")).isEqualTo("foo_bar\\=\\,\\ baz"); }
@Test void timeCannotBeATagKey() { assertThat(catchThrowable(() -> convention.tagKey("time"))).isInstanceOf(IllegalArgumentException.class); } |
InfluxNamingConvention implements NamingConvention { @Override public String tagValue(String value) { return escape(this.delegate.tagValue(value).replace('\n', ' ')); } InfluxNamingConvention(); InfluxNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagValue() { assertThat(convention.tagValue("foo=, bar")).isEqualTo("foo\\=\\,\\ bar"); }
@Test void timeCanBeATagValue() { assertThat(convention.tagValue("time")).isEqualTo("time"); }
@Issue("#645") @Test void namingConventionIsNotAppliedToTagValues() { assertThat(convention.tagValue("org.example.service=")).isEqualTo("org.example.service\\="); }
@Issue("#2155") @Test void newlineCharReplacedInTagValues() { assertThat(convention.tagValue("hello\nworld\n")).isEqualTo("hello\\ world\\ "); } |
CreateDatabaseQueryBuilder { String build() { StringBuilder queryStringBuilder = new StringBuilder(String.format(QUERY_MANDATORY_TEMPLATE, databaseName)); if (hasAnyRetentionPolicy()) { String retentionPolicyClause = Stream.of(retentionPolicyClauses).filter(Objects::nonNull) .reduce(RETENTION_POLICY_INTRODUCTION, String::concat); queryStringBuilder.append(retentionPolicyClause); } return queryStringBuilder.toString(); } CreateDatabaseQueryBuilder(String databaseName); } | @Test void noRetentionPolicy() { String query = createDatabaseQueryBuilder.build(); assertEquals("CREATE DATABASE \"dummy_database_0\"", query); } |
InfluxMeterRegistry extends StepMeterRegistry { Stream<String> writeGauge(Meter.Id id, Double value) { if (Double.isFinite(value)) { return Stream.of(influxLineProtocol(id, "gauge", Stream.of(new Field("value", value)))); } return Stream.empty(); } @SuppressWarnings("deprecation") InfluxMeterRegistry(InfluxConfig config, Clock clock); @Deprecated InfluxMeterRegistry(InfluxConfig config, Clock clock, ThreadFactory threadFactory); private InfluxMeterRegistry(InfluxConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(InfluxConfig config); } | @Test void writeGauge() { meterRegistry.gauge("my.gauge", 1d); Gauge gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge.getId(), 1d)).hasSize(1); }
@Test void writeGaugeShouldDropNanValue() { meterRegistry.gauge("my.gauge", Double.NaN); Gauge gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge.getId(), Double.NaN)).isEmpty(); }
@Test void writeGaugeShouldDropInfiniteValues() { meterRegistry.gauge("my.gauge", Double.POSITIVE_INFINITY); Gauge gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge.getId(), Double.POSITIVE_INFINITY)).isEmpty(); meterRegistry.gauge("my.gauge", Double.NEGATIVE_INFINITY); gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge.getId(), Double.NEGATIVE_INFINITY)).isEmpty(); }
@Test void writeTimeGauge() { AtomicReference<Double> obj = new AtomicReference<>(1d); meterRegistry.more().timeGauge("my.timeGauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); TimeGauge timeGauge = meterRegistry.find("my.timeGauge").timeGauge(); assertThat(meterRegistry.writeGauge(timeGauge.getId(), 1d)).hasSize(1); }
@Test void writeTimeGaugeShouldDropNanValue() { AtomicReference<Double> obj = new AtomicReference<>(Double.NaN); meterRegistry.more().timeGauge("my.timeGauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); TimeGauge timeGauge = meterRegistry.find("my.timeGauge").timeGauge(); assertThat(meterRegistry.writeGauge(timeGauge.getId(), Double.NaN)).isEmpty(); }
@Test void writeTimeGaugeShouldDropInfiniteValues() { AtomicReference<Double> obj = new AtomicReference<>(Double.POSITIVE_INFINITY); meterRegistry.more().timeGauge("my.timeGauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); TimeGauge timeGauge = meterRegistry.find("my.timeGauge").timeGauge(); assertThat(meterRegistry.writeGauge(timeGauge.getId(), Double.POSITIVE_INFINITY)).isEmpty(); obj = new AtomicReference<>(Double.NEGATIVE_INFINITY); meterRegistry.more().timeGauge("my.timeGauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); timeGauge = meterRegistry.find("my.timeGauge").timeGauge(); assertThat(meterRegistry.writeGauge(timeGauge.getId(), Double.NEGATIVE_INFINITY)).isEmpty(); }
@Test void writeShouldDropTagWithBlankValue() { meterRegistry.gauge("my.gauge", Tags.of("foo", "bar").and("baz", ""), 1d); final Gauge gauge = meterRegistry.find("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge.getId(), 1d)) .hasSize(1) .allSatisfy(s -> assertThat(s) .contains("foo=bar") .doesNotContain("baz")); } |
NewRelicNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return StringEscapeUtils.escapeJson(toValidNewRelicString(delegate.tagKey(key))); } NewRelicNamingConvention(); NewRelicNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagKey() { String validString = newRelicNamingConvention.tagKey(VALID_NAME); assertThat(validString).isEqualTo(VALID_NAME); }
@Test void tagKeyShouldStripInvalidCharacters() { String validString = newRelicNamingConvention.tagKey(INVALID_NAME); assertThat(validString).isEqualTo("invalid_name"); } |
InfluxMeterRegistry extends StepMeterRegistry { Stream<String> writeFunctionTimer(FunctionTimer timer) { double sum = timer.totalTime(getBaseTimeUnit()); if (Double.isFinite(sum)) { Stream.Builder<Field> builder = Stream.builder(); builder.add(new Field("sum", sum)); builder.add(new Field("count", timer.count())); double mean = timer.mean(getBaseTimeUnit()); if (Double.isFinite(mean)) { builder.add(new Field("mean", mean)); } return Stream.of(influxLineProtocol(timer.getId(), "histogram", builder.build())); } return Stream.empty(); } @SuppressWarnings("deprecation") InfluxMeterRegistry(InfluxConfig config, Clock clock); @Deprecated InfluxMeterRegistry(InfluxConfig config, Clock clock, ThreadFactory threadFactory); private InfluxMeterRegistry(InfluxConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(InfluxConfig config); } | @Test void nanMeanFunctionTimerShouldNotWriteMean() { FunctionTimer functionTimer = new FunctionTimer() { @Override public double count() { return 1; } @Override public double totalTime(TimeUnit unit) { return 1; } @Override public TimeUnit baseTimeUnit() { return TimeUnit.SECONDS; } @Override public Id getId() { return new Id("func.timer", Tags.empty(), null, null, Type.TIMER); } @Override public double mean(TimeUnit unit) { return Double.NaN; } }; assertThat(meterRegistry.writeFunctionTimer(functionTimer)) .containsOnly("func_timer,metric_type=histogram sum=1,count=1 1"); } |
GraphiteMeterRegistry extends DropwizardMeterRegistry { @Override public void close() { if (config.enabled()) { reporter.close(); } super.close(); } GraphiteMeterRegistry(GraphiteConfig config, Clock clock); GraphiteMeterRegistry(GraphiteConfig config, Clock clock, HierarchicalNameMapper nameMapper); GraphiteMeterRegistry(GraphiteConfig config, Clock clock, HierarchicalNameMapper nameMapper,
MetricRegistry metricRegistry); GraphiteMeterRegistry(GraphiteConfig config, Clock clock, HierarchicalNameMapper nameMapper,
MetricRegistry metricRegistry, GraphiteReporter reporter); void stop(); void start(); @Override void close(); } | @Test void metricPrefixes() throws InterruptedException { final CountDownLatch receiveLatch = new CountDownLatch(1); final GraphiteMeterRegistry registry = new GraphiteMeterRegistry(new GraphiteConfig() { @Override @Nullable public String get(String key) { return null; } @Override public boolean graphiteTagsEnabled() { return false; } @Override public Duration step() { return Duration.ofSeconds(1); } @Override public GraphiteProtocol protocol() { return GraphiteProtocol.UDP; } @Override public int port() { return PORT; } @Override public String[] tagsAsPrefix() { return new String[]{"application"}; } }, mockClock); Connection server = UdpServer.create() .option(ChannelOption.SO_REUSEADDR, true) .host("localhost") .port(PORT) .handle((in, out) -> { in.receive() .asString() .subscribe(line -> { assertThat(line).startsWith("APPNAME.myTimer"); receiveLatch.countDown(); }); return Flux.never(); }) .bind() .doOnSuccess(v -> { registry.timer("my.timer", "application", "APPNAME") .record(1, TimeUnit.MILLISECONDS); registry.close(); }) .block(Duration.ofSeconds(10)); assertTrue(receiveLatch.await(10, TimeUnit.SECONDS), "line was received"); server.dispose(); }
@Test void taggedMetrics() throws InterruptedException { final CountDownLatch receiveLatch = new CountDownLatch(1); final GraphiteMeterRegistry registry = new GraphiteMeterRegistry(new GraphiteConfig() { @Override @Nullable public String get(String key) { return null; } @Override public boolean graphiteTagsEnabled() { return true; } @Override public Duration step() { return Duration.ofSeconds(1); } @Override public GraphiteProtocol protocol() { return GraphiteProtocol.UDP; } @Override public int port() { return PORT; } @Override public String[] tagsAsPrefix() { return new String[] {}; } }, mockClock); Connection server = UdpServer.create() .option(ChannelOption.SO_REUSEADDR, true) .host("localhost") .port(PORT) .handle((in, out) -> { in.receive() .asString() .subscribe(line -> { assertThat(line).startsWith("my.timer;key=value;metricattribute=max "); receiveLatch.countDown(); }); return Flux.never(); }) .bind() .doOnSuccess(v -> { registry.timer("my.timer", "key", "value") .record(1, TimeUnit.MILLISECONDS); registry.close(); }) .block(Duration.ofSeconds(10)); assertTrue(receiveLatch.await(10, TimeUnit.SECONDS), "line was received"); server.dispose(); } |
GraphiteHierarchicalNameMapper implements HierarchicalNameMapper { @Override public String toHierarchicalName(Meter.Id id, NamingConvention convention) { StringBuilder hierarchicalName = new StringBuilder(); for (String tagKey : tagsAsPrefix) { String tagValue = id.getTag(tagKey); if (tagValue != null) { hierarchicalName.append(convention.tagValue(tagValue)).append("."); } } hierarchicalName.append(id.getConventionName(convention)); for (Tag tag : id.getTagsAsIterable()) { if (!tagsAsPrefix.contains(tag.getKey())) { hierarchicalName.append('.').append(convention.tagKey(tag.getKey())) .append('.').append(convention.tagValue(tag.getValue())); } } return hierarchicalName.toString(); } GraphiteHierarchicalNameMapper(String... tagsAsPrefix); @Override String toHierarchicalName(Meter.Id id, NamingConvention convention); } | @Issue("#561") @Test void tagsAsPrefix() { assertThat(nameMapper.toHierarchicalName(id, NamingConvention.camelCase)) .isEqualTo("PROD.MYAPP.myName.otherTag.value"); }
@Test void toHierarchicalNameShouldSanitizeTagValueFromTagsAsPrefix() { Meter.Id id = new SimpleMeterRegistry().counter("my.name", "app.name", "MY APP", "stack", "PROD", "other.tag", "value").getId(); assertThat(nameMapper.toHierarchicalName(id, new GraphiteHierarchicalNamingConvention())) .isEqualTo("PROD.MY_APP.myName.otherTag.value"); } |
GraphiteHierarchicalNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return sanitizeName(this.delegate.name(normalize(name), type, baseUnit)); } GraphiteHierarchicalNamingConvention(); GraphiteHierarchicalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void name() { assertThat(convention.name("name([{id}])/1", Meter.Type.TIMER)).isEqualTo("name___id____1"); }
@Test void dotNotationIsConvertedToCamelCase() { assertThat(convention.name("gauge.size", Meter.Type.GAUGE)).isEqualTo("gaugeSize"); }
@Test void nameShouldPreserveDot() { GraphiteHierarchicalNamingConvention convention = new GraphiteHierarchicalNamingConvention(NamingConvention.identity); assertThat(convention.name("my.counter", Meter.Type.COUNTER)).isEqualTo("my.counter"); }
@Test void nameShouldSanitizeSpace() { assertThat(convention.name("counter 1", Meter.Type.COUNTER)).isEqualTo("counter_1"); }
@Test void nameShouldSanitizeQuestionMark() { assertThat(convention.name("counter?1", Meter.Type.COUNTER)).isEqualTo("counter_1"); }
@Test void nameShouldSanitizeColon() { assertThat(convention.name("counter:1", Meter.Type.COUNTER)).isEqualTo("counter_1"); } |
GraphiteHierarchicalNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return sanitizeTag(this.delegate.tagKey(normalize(key))); } GraphiteHierarchicalNamingConvention(); GraphiteHierarchicalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagKeyShouldSanitizeDot() { GraphiteHierarchicalNamingConvention convention = new GraphiteHierarchicalNamingConvention(NamingConvention.identity); assertThat(convention.tagKey("my.tag")).isEqualTo("my_tag"); }
@Test void tagKeyShouldSanitizeSpace() { assertThat(convention.tagKey("tag 1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldSanitizeQuestionMark() { assertThat(convention.tagKey("tag?1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldSanitizeColon() { assertThat(convention.tagKey("tag:1")).isEqualTo("tag_1"); }
@Test void tagValueShouldSanitizeSpace() { assertThat(convention.tagKey("value 1")).isEqualTo("value_1"); }
@Test void tagValueShouldSanitizeQuestionMark() { assertThat(convention.tagKey("value?1")).isEqualTo("value_1"); }
@Test void tagValueShouldSanitizeColon() { assertThat(convention.tagKey("value:1")).isEqualTo("value_1"); } |
GraphiteHierarchicalNamingConvention implements NamingConvention { @Override public String tagValue(String value) { return sanitizeTag(this.delegate.tagValue(normalize(value))); } GraphiteHierarchicalNamingConvention(); GraphiteHierarchicalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagValueShouldSanitizeDot() { assertThat(convention.tagValue("my.value")).isEqualTo("my_value"); } |
NewRelicNamingConvention implements NamingConvention { @Override public String tagValue(String value) { return StringEscapeUtils.escapeJson(delegate.tagValue(value)); } NewRelicNamingConvention(); NewRelicNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagValue() { String validString = newRelicNamingConvention.tagValue(VALID_NAME); assertThat(validString).isEqualTo(VALID_NAME); }
@Test void tagValueShouldNotStripInvalidCharacters() { String validString = newRelicNamingConvention.tagValue(INVALID_NAME); assertThat(validString).isEqualTo(INVALID_NAME); } |
GraphiteDimensionalNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return sanitizeName(this.delegate.name(normalize(name), type, baseUnit)); } GraphiteDimensionalNamingConvention(); GraphiteDimensionalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void name() { assertThat(convention.name("name([{id}])/1", Meter.Type.TIMER)).isEqualTo("name___id____1"); }
@Test void nameShouldPreserveDot() { assertThat(convention.name("my.counter", Meter.Type.COUNTER)).isEqualTo("my.counter"); }
@Test void nameShouldSanitizeSpace() { assertThat(convention.name("counter 1", Meter.Type.COUNTER)).isEqualTo("counter_1"); }
@Test void nameShouldSanitizeQuestionMark() { assertThat(convention.name("counter?1", Meter.Type.COUNTER)).isEqualTo("counter_1"); }
@Test void nameShouldSanitizeSemiColon() { assertThat(convention.name("counter;1", Meter.Type.COUNTER)).isEqualTo("counter_1"); }
@Test void nameShouldSanitizeColon() { assertThat(convention.name("counter:1", Meter.Type.COUNTER)).isEqualTo("counter_1"); } |
GraphiteDimensionalNamingConvention implements NamingConvention { @Override public String tagKey(String key) { if (key.isEmpty()) { return UNSPECIFIED; } return sanitizeTagKey(this.delegate.tagKey(normalize(key))); } GraphiteDimensionalNamingConvention(); GraphiteDimensionalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagKeyShouldPreserveDot() { assertThat(convention.tagKey("my.tag")).isEqualTo("my.tag"); }
@Test void tagKeyShouldPreserveSpace() { assertThat(convention.tagKey("tag 1")).isEqualTo("tag 1"); }
@Test void tagKeyShouldPreserveQuestionMark() { assertThat(convention.tagKey("tag?1")).isEqualTo("tag?1"); }
@Test void tagKeyShouldPreserveColon() { assertThat(convention.tagKey("tag:1")).isEqualTo("tag:1"); }
@Test void tagKeyShouldSanitizeSemiColon() { assertThat(convention.tagKey("tag;1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldSanitizeExclamation() { assertThat(convention.tagKey("tag!1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldSanitizeCarat() { assertThat(convention.tagKey("tag^1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldSanitizeEquals() { assertThat(convention.tagKey("tag=1")).isEqualTo("tag_1"); }
@Test void tagKeyShouldPreserveTilde() { assertThat(convention.tagKey("tag~1")).isEqualTo("tag~1"); }
@Test void tagKeyShouldHaveLengthGreaterThanZero() { assertThat(convention.tagKey("")).isEqualTo("unspecified"); } |
GraphiteDimensionalNamingConvention implements NamingConvention { @Override public String tagValue(String value) { if (value.isEmpty()) { return UNSPECIFIED; } return sanitizeTagValue(this.delegate.tagValue(normalize(value))); } GraphiteDimensionalNamingConvention(); GraphiteDimensionalNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagValueShouldPreserveDot() { assertThat(convention.tagValue("my.tag")).isEqualTo("my.tag"); }
@Test void tagValueShouldPreserveSpace() { assertThat(convention.tagValue("tag 1")).isEqualTo("tag 1"); }
@Test void tagValueShouldPreserveQuestionMark() { assertThat(convention.tagValue("tag?1")).isEqualTo("tag?1"); }
@Test void tagValueShouldPreserveColon() { assertThat(convention.tagValue("tag:1")).isEqualTo("tag:1"); }
@Test void tagValueShouldSanitizeSemiColon() { assertThat(convention.tagValue("tag;1")).isEqualTo("tag_1"); }
@Test void tagValueShouldPreserveExclamation() { assertThat(convention.tagValue("tag!1")).isEqualTo("tag!1"); }
@Test void tagValueShouldPreserveCarat() { assertThat(convention.tagValue("tag^1")).isEqualTo("tag^1"); }
@Test void tagValueShouldPreserveEquals() { assertThat(convention.tagValue("tag=1")).isEqualTo("tag=1"); }
@Test void tagValueShouldSanitizeTilde() { assertThat(convention.tagValue("tag~1")).isEqualTo("tag_1"); }
@Test void tagValueShouldHaveLengthGreaterThanZero() { assertThat(convention.tagValue("")).isEqualTo("unspecified"); } |
OpenTSDBMeterRegistry extends PushMeterRegistry { Stream<String> writeGauge(Gauge gauge) { double value = gauge.value(); if (Double.isFinite(value)) { return Stream.of(writeMetric(gauge.getId(), config().clock().wallTime(), value)); } return Stream.empty(); } @SuppressWarnings("deprecation") OpenTSDBMeterRegistry(OpenTSDBConfig config, Clock clock); OpenTSDBMeterRegistry(OpenTSDBConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(OpenTSDBConfig config); @Override Counter newCounter(Meter.Id id); @Override DistributionSummary newDistributionSummary(Meter.Id id, DistributionStatisticConfig distributionStatisticConfig, double scale); } | @Test void writeGauge() { meterRegistry.gauge("my.gauge", 1d); Gauge gauge = meterRegistry.get("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).hasSize(1); }
@Test void writeGaugeShouldDropNanValue() { meterRegistry.gauge("my.gauge", Double.NaN); Gauge gauge = meterRegistry.get("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); }
@Test void writeGaugeShouldDropInfiniteValues() { meterRegistry.gauge("my.gauge", Double.POSITIVE_INFINITY); Gauge gauge = meterRegistry.get("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); meterRegistry.gauge("my.gauge", Double.NEGATIVE_INFINITY); gauge = meterRegistry.get("my.gauge").gauge(); assertThat(meterRegistry.writeGauge(gauge)).isEmpty(); } |
CloudWatchMeterRegistry extends StepMeterRegistry { List<MetricDatum> metricData() { Batch batch = new Batch(); return getMeters().stream().flatMap(m -> m.match( batch::gaugeData, batch::counterData, batch::timerData, batch::summaryData, batch::longTaskTimerData, batch::timeGaugeData, batch::functionCounterData, batch::functionTimerData, batch::metricData) ).collect(toList()); } CloudWatchMeterRegistry(CloudWatchConfig config, Clock clock,
CloudWatchAsyncClient cloudWatchAsyncClient); CloudWatchMeterRegistry(CloudWatchConfig config, Clock clock,
CloudWatchAsyncClient cloudWatchAsyncClient, ThreadFactory threadFactory); } | @Test void metricData() { registry.gauge("gauge", 1d); List<MetricDatum> metricDatumStream = registry.metricData(); assertThat(metricDatumStream.size()).isEqualTo(1); }
@Test void metricDataWhenNaNShouldNotAdd() { registry.gauge("gauge", Double.NaN); AtomicReference<Double> value = new AtomicReference<>(Double.NaN); registry.more().timeGauge("time.gauge", Tags.empty(), value, TimeUnit.MILLISECONDS, AtomicReference::get); List<MetricDatum> metricDatumStream = registry.metricData(); assertThat(metricDatumStream.size()).isEqualTo(0); }
@Test void writeMeterWhenCustomMeterHasOnlyNaNValuesShouldNotBeWritten() { Measurement measurement = new Measurement(() -> Double.NaN, Statistic.VALUE); List<Measurement> measurements = Arrays.asList(measurement); Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.registry); assertThat(registry.new Batch().metricData(meter)).isEmpty(); }
@Test void writeMeterWhenCustomMeterHasMixedNaNAndNonNaNValuesShouldSkipOnlyNaNValues() { Measurement measurement1 = new Measurement(() -> Double.NaN, Statistic.VALUE); Measurement measurement2 = new Measurement(() -> 1d, Statistic.VALUE); Measurement measurement3 = new Measurement(() -> 2d, Statistic.VALUE); List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3); Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.registry); assertThat(registry.new Batch().metricData(meter)).hasSize(2); }
@Test void writeShouldDropTagWithBlankValue() { registry.gauge("my.gauge", Tags.of("accepted", "foo").and("empty", ""), 1d); assertThat(registry.metricData()) .hasSize(1) .allSatisfy(datum -> assertThat(datum.dimensions()).hasSize(1).contains( Dimension.builder().name("accepted").value("foo").build())); } |
CloudWatchUtils { static double clampMetricValue(double value) { if (Double.isNaN(value)) { return value; } double magnitude = Math.abs(value); if (magnitude == 0) { return 0; } double clampedMag = Math.min(Math.max(magnitude, MINIMUM_ALLOWED_VALUE), MAXIMUM_ALLOWED_VALUE); return Math.copySign(clampedMag, value); } private CloudWatchUtils(); } | @Test void testClamp() { assertThat(CloudWatchUtils.clampMetricValue(Double.NaN)) .as("Check NaN") .isNaN(); assertThat(CloudWatchUtils.clampMetricValue(Double.MIN_VALUE)) .as("Check minimum value") .isEqualTo(EXPECTED_MIN); assertThat(CloudWatchUtils.clampMetricValue(Double.NEGATIVE_INFINITY)) .as("Check negative infinity") .isEqualTo(-EXPECTED_MAX); assertThat(CloudWatchUtils.clampMetricValue(Double.POSITIVE_INFINITY)) .as("Check positive infinity") .isEqualTo(EXPECTED_MAX); assertThat(CloudWatchUtils.clampMetricValue(-Double.MAX_VALUE)) .as("Check negative max value") .isEqualTo(-EXPECTED_MAX); assertThat(CloudWatchUtils.clampMetricValue(0)) .as("Check 0") .isEqualTo(0); assertThat(CloudWatchUtils.clampMetricValue(-0)) .as("Check -0") .isEqualTo(0); assertThat(CloudWatchUtils.clampMetricValue(100.1)) .as("Check positive value") .isEqualTo(100.1); assertThat(CloudWatchUtils.clampMetricValue(-10.2)) .as("Check negative value") .isEqualTo(-10.2); } |
CloudWatchNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return StringUtils.truncate(delegate.tagKey(key), MAX_TAG_KEY_LENGTH); } CloudWatchNamingConvention(); CloudWatchNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void truncateTagKey() { assertThat(namingConvention.tagKey(repeat("x", 256))).hasSize(255); } |
CloudWatchNamingConvention implements NamingConvention { @Override public String tagValue(String value) { return StringUtils.truncate(delegate.tagValue(value), MAX_TAG_VALUE_LENGTH); } CloudWatchNamingConvention(); CloudWatchNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void truncateTagValue() { assertThat(namingConvention.tagValue(repeat("x", 256))).hasSize(255); } |
HumioNamingConvention implements NamingConvention { @Override public String tagKey(String key) { if (key.equals("name")) { key = "name.tag"; } return delegate.tagKey(key); } HumioNamingConvention(); HumioNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); } | @Test void replaceNameTag() { assertThat(namingConvention.tagKey("name")).isEqualTo("name_tag"); } |
HumioMeterRegistry extends StepMeterRegistry { public static Builder builder(HumioConfig config) { return new Builder(config); } @SuppressWarnings("deprecation") HumioMeterRegistry(HumioConfig config, Clock clock); private HumioMeterRegistry(HumioConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(HumioConfig config); } | @Test void writeFunctionCounter() { FunctionCounter counter = FunctionCounter.builder("myCounter", 1d, Number::doubleValue).register(meterRegistry); clock.add(config.step()); assertThat(createBatch().writeFunctionCounter(counter)).isNotNull(); }
@Test void writeFunctionCounterShouldDropPositiveInfiniteValue() { FunctionCounter counter = FunctionCounter.builder("myCounter", Double.POSITIVE_INFINITY, Number::doubleValue).register(meterRegistry); clock.add(config.step()); assertThat(createBatch().writeFunctionCounter(counter)).isNull(); }
@Test void writeFunctionCounterShouldDropNegativeInfiniteValue() { FunctionCounter counter = FunctionCounter.builder("myCounter", Double.NEGATIVE_INFINITY, Number::doubleValue).register(meterRegistry); clock.add(config.step()); assertThat(createBatch().writeFunctionCounter(counter)).isNull(); }
@Test void writeMeterWhenCustomMeterHasOnlyNonFiniteValuesShouldNotBeWritten() { Measurement measurement1 = new Measurement(() -> Double.POSITIVE_INFINITY, Statistic.VALUE); Measurement measurement2 = new Measurement(() -> Double.NEGATIVE_INFINITY, Statistic.VALUE); Measurement measurement3 = new Measurement(() -> Double.NaN, Statistic.VALUE); List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3); Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.meterRegistry); assertThat(createBatch().writeMeter(meter)).isNull(); }
@Test void writeMeterWhenCustomMeterHasMixedFiniteAndNonFiniteValuesShouldSkipOnlyNonFiniteValues() { Measurement measurement1 = new Measurement(() -> Double.POSITIVE_INFINITY, Statistic.VALUE); Measurement measurement2 = new Measurement(() -> Double.NEGATIVE_INFINITY, Statistic.VALUE); Measurement measurement3 = new Measurement(() -> Double.NaN, Statistic.VALUE); Measurement measurement4 = new Measurement(() -> 1d, Statistic.VALUE); Measurement measurement5 = new Measurement(() -> 2d, Statistic.VALUE); List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3, measurement4, measurement5); Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.meterRegistry); assertThat(createBatch().writeMeter(meter)) .isEqualTo("{\"timestamp\":\"1970-01-01T00:00:00.001Z\",\"attributes\":{\"name\":\"my_meter\",\"value\":1,\"value\":2}}"); } |
DatadogMetricMetadata { String editMetadataBody() { if (descriptionsEnabled && id.getDescription() != null) { String body = "{\"type\":\"" + type + "\""; String baseUnit = sanitizeBaseUnit(id.getBaseUnit(), overrideBaseUnit); if (baseUnit != null) { body += ",\"unit\":\"" + baseUnit + "\""; } body += ",\"description\":\"" + StringEscapeUtils.escapeJson(id.getDescription()) + "\"}"; return body; } return null; } DatadogMetricMetadata(Meter.Id id, Statistic statistic, boolean descriptionsEnabled,
@Nullable String overrideBaseUnit); } | @Test void escapesStringsInDescription() { DatadogMetricMetadata metricMetadata = new DatadogMetricMetadata( Counter.builder("name") .tag("key", "value") .description("The /\"recent cpu usage\" for the Java Virtual Machine process") .register(new SimpleMeterRegistry()).getId(), Statistic.COUNT, true, null ); assertThat(metricMetadata.editMetadataBody()).isEqualTo("{\"type\":\"count\",\"description\":\"The /\\\"recent cpu usage\\\" for the Java Virtual Machine process\"}"); }
@Test void unitsAreConverted() { DatadogMetricMetadata metricMetadata = new DatadogMetricMetadata( Timer.builder("name") .tag("key", "value") .description("Time spent in GC pause") .register(new DatadogMeterRegistry(new DatadogConfig() { @Override public String apiKey() { return "fake"; } @Override public String get(String key) { return null; } }, Clock.SYSTEM)).getId(), Statistic.TOTAL_TIME, false, null); assertThat(metricMetadata.editMetadataBody()).isNull(); } |
DatadogNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { String sanitized = StringEscapeUtils.escapeJson(delegate.name(name, type, baseUnit) .replace('/', '_')); if (!Character.isLetter(sanitized.charAt(0))) { sanitized = "m." + sanitized; } return StringUtils.truncate(sanitized, MAX_NAME_LENGTH); } DatadogNamingConvention(); DatadogNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void nameStartsWithLetter() { assertThat(convention.name("123", Meter.Type.GAUGE, null)).isEqualTo("m.123"); }
@Test void dotNotationIsConvertedToCamelCase() { assertThat(convention.name("gauge.size", Meter.Type.GAUGE, null)).isEqualTo("gauge.size"); } |
DatadogNamingConvention implements NamingConvention { @Override public String tagKey(String key) { String sanitized = StringEscapeUtils.escapeJson(delegate.tagKey(key)); if (Character.isDigit(sanitized.charAt(0))) { sanitized = "m." + sanitized; } return sanitized; } DatadogNamingConvention(); DatadogNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagKeyStartsWithLetter() { assertThat(convention.tagKey("123")).isEqualTo("m.123"); }
@Test void tagKeyWhenStartsWithNumberShouldRespectDelegateNamingConvention() { String tagKey = "123"; NamingConvention delegate = new NamingConvention() { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return name; } @Override public String tagKey(String key) { return "123456"; } }; assertThat(delegate.tagKey(tagKey)).isEqualTo("123456"); DatadogNamingConvention convention = new DatadogNamingConvention(delegate); assertThat(convention.tagKey(tagKey)).isEqualTo("m.123456"); } |
WavefrontNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { String sanitizedName = NAME_CLEANUP_PATTERN.matcher(delegate.name(name, type, baseUnit)).replaceAll("_"); if (namePrefix != null) { return namePrefix + "." + sanitizedName; } return sanitizedName; } WavefrontNamingConvention(@Nullable String namePrefix); WavefrontNamingConvention(@Nullable String namePrefix, NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void name() { assertThat(convention.name("123abc/{:id}水", Meter.Type.GAUGE)).isEqualTo("123abc/__id__"); } |
WavefrontNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return KEY_CLEANUP_PATTERN.matcher(delegate.tagKey(key)).replaceAll("_"); } WavefrontNamingConvention(@Nullable String namePrefix); WavefrontNamingConvention(@Nullable String namePrefix, NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagKey() { assertThat(convention.tagKey("123abc/{:id}水")).isEqualTo("123abc___id__"); } |
WavefrontNamingConvention implements NamingConvention { @Override public String tagValue(String value) { String sanitized = delegate.tagValue(value); return StringEscapeUtils.escapeJson(sanitized.endsWith("\\") ? sanitized.substring(0, sanitized.length() - 1) + "_" : sanitized); } WavefrontNamingConvention(@Nullable String namePrefix); WavefrontNamingConvention(@Nullable String namePrefix, NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagValue() { assertThat(convention.tagValue("123abc/\"{:id}水\\")).isEqualTo("123abc/\\\"{:id}水_"); assertThat(convention.tagValue("\\")).isEqualTo("_"); } |
WavefrontMeterRegistry extends PushMeterRegistry { void publishMetric(Meter.Id id, @Nullable String suffix, long wallTime, double value) { if (!Double.isFinite(value)) { return; } Meter.Id fullId = id; if (suffix != null) { fullId = idWithSuffix(id, suffix); } String name = getConventionName(fullId); String source = config.source(); Map<String, String> tags = getTagsAsMap(id); try { wavefrontSender.sendMetric(name, value, wallTime, source, tags); } catch (IOException e) { logger.warn("failed to report metric to Wavefront: " + fullId.getName(), e); } } WavefrontMeterRegistry(WavefrontConfig config, Clock clock); @Deprecated WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory); WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory,
WavefrontSender wavefrontSender); static WavefrontClient.Builder getDefaultSenderBuilder(WavefrontConfig config); static Builder builder(WavefrontConfig config); } | @Test void publishMetric() throws IOException { Meter.Id id = registry.counter("name").getId(); long time = System.currentTimeMillis(); registry.publishMetric(id, null, System.currentTimeMillis(), 1d); verify(wavefrontSender, times(1)).sendMetric("name", 1d, time, "host", Collections.emptyMap()); verifyNoMoreInteractions(wavefrontSender); }
@Test void publishMetricWhenNanOrInfinityShouldNotAdd() { Meter.Id id = registry.counter("name").getId(); registry.publishMetric(id, null, System.currentTimeMillis(), Double.NaN); registry.publishMetric(id, null, System.currentTimeMillis(), Double.POSITIVE_INFINITY); verifyNoInteractions(wavefrontSender); } |
OpenTSDBMeterRegistry extends PushMeterRegistry { Stream<String> writeTimeGauge(TimeGauge timeGauge) { double value = timeGauge.value(getBaseTimeUnit()); if (Double.isFinite(value)) { return Stream.of(writeMetric(timeGauge.getId(), config().clock().wallTime(), value)); } return Stream.empty(); } @SuppressWarnings("deprecation") OpenTSDBMeterRegistry(OpenTSDBConfig config, Clock clock); OpenTSDBMeterRegistry(OpenTSDBConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(OpenTSDBConfig config); @Override Counter newCounter(Meter.Id id); @Override DistributionSummary newDistributionSummary(Meter.Id id, DistributionStatisticConfig distributionStatisticConfig, double scale); } | @Test void writeTimeGauge() { AtomicReference<Double> obj = new AtomicReference<>(1d); meterRegistry.more().timeGauge("my.time.gauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); TimeGauge timeGauge = meterRegistry.get("my.time.gauge").timeGauge(); assertThat(meterRegistry.writeTimeGauge(timeGauge)).hasSize(1); }
@Test void writeTimeGaugeShouldDropNanValue() { AtomicReference<Double> obj = new AtomicReference<>(Double.NaN); meterRegistry.more().timeGauge("my.time.gauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); TimeGauge timeGauge = meterRegistry.get("my.time.gauge").timeGauge(); assertThat(meterRegistry.writeTimeGauge(timeGauge)).isEmpty(); }
@Test void writeTimeGaugeShouldDropInfiniteValues() { AtomicReference<Double> obj = new AtomicReference<>(Double.POSITIVE_INFINITY); meterRegistry.more().timeGauge("my.time.gauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); TimeGauge timeGauge = meterRegistry.get("my.time.gauge").timeGauge(); assertThat(meterRegistry.writeTimeGauge(timeGauge)).isEmpty(); obj = new AtomicReference<>(Double.NEGATIVE_INFINITY); meterRegistry.more().timeGauge("my.time.gauge", Tags.empty(), obj, TimeUnit.SECONDS, AtomicReference::get); timeGauge = meterRegistry.get("my.time.gauge").timeGauge(); assertThat(meterRegistry.writeTimeGauge(timeGauge)).isEmpty(); } |
WavefrontMeterRegistry extends PushMeterRegistry { void publishDistribution(Meter.Id id, List<WavefrontHistogramImpl.Distribution> distributions) { String name = getConventionName(id); String source = config.source(); Map<String, String> tags = getTagsAsMap(id); for (WavefrontHistogramImpl.Distribution distribution : distributions) { try { wavefrontSender.sendDistribution(name, distribution.centroids, histogramGranularities, distribution.timestamp, source, tags); } catch (IOException e) { logger.warn("failed to send distribution to Wavefront: " + id.getName(), e); } } } WavefrontMeterRegistry(WavefrontConfig config, Clock clock); @Deprecated WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory); WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory,
WavefrontSender wavefrontSender); static WavefrontClient.Builder getDefaultSenderBuilder(WavefrontConfig config); static Builder builder(WavefrontConfig config); } | @Test void publishDistribution() throws IOException { Meter.Id id = registry.summary("name").getId(); long time = System.currentTimeMillis(); List<Pair<Double, Integer>> centroids = Arrays.asList(new Pair<>(1d, 1)); List<WavefrontHistogramImpl.Distribution> distributions = Arrays.asList( new WavefrontHistogramImpl.Distribution(time, centroids) ); registry.publishDistribution(id, distributions); verify(wavefrontSender, times(1)).sendDistribution("name", centroids, Collections.singleton(HistogramGranularity.MINUTE), time, "host", Collections.emptyMap()); verifyNoMoreInteractions(wavefrontSender); } |
WavefrontMeterRegistry extends PushMeterRegistry { public static WavefrontClient.Builder getDefaultSenderBuilder(WavefrontConfig config) { return new WavefrontClient.Builder(getWavefrontReportingUri(config), config.apiToken()).batchSize(config.batchSize()) .flushInterval((int) config.step().toMillis(), TimeUnit.MILLISECONDS); } WavefrontMeterRegistry(WavefrontConfig config, Clock clock); @Deprecated WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory); WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory,
WavefrontSender wavefrontSender); static WavefrontClient.Builder getDefaultSenderBuilder(WavefrontConfig config); static Builder builder(WavefrontConfig config); } | @Test @Issue("#2173") void defaultStepConfigAffectsWavefrontBuilder() { WavefrontClient.Builder defaultSenderBuilder = WavefrontMeterRegistry.getDefaultSenderBuilder(config); assertThat(defaultSenderBuilder).hasFieldOrPropertyWithValue("flushInterval", 60_000L); assertThat(defaultSenderBuilder).hasFieldOrPropertyWithValue("flushIntervalTimeUnit", TimeUnit.MILLISECONDS); }
@Test void configureDefaultSenderWithCustomConfig() { WavefrontConfig customConfig = new WavefrontConfig() { @Override public String get(String key) { return null; } @Override public String uri() { return "https: } @Override public String apiToken() { return "apiToken"; } @Override public int batchSize() { return 20; } @Override public Duration step() { return Duration.ofSeconds(15); } }; WavefrontClient.Builder builder = WavefrontMeterRegistry.getDefaultSenderBuilder(customConfig); WavefrontClient sender = builder.build(); assertThat(builder).hasFieldOrPropertyWithValue("flushInterval", 15_000L); assertThat(builder).hasFieldOrPropertyWithValue("flushIntervalTimeUnit", TimeUnit.MILLISECONDS); assertThat(sender).extracting("reportingService").hasFieldOrPropertyWithValue("uri", URI.create("https: assertThat(sender).extracting("reportingService").hasFieldOrPropertyWithValue("token", "apiToken"); assertThat(sender).hasFieldOrPropertyWithValue("batchSize", 20); } |
WavefrontMeterRegistry extends PushMeterRegistry { public static Builder builder(WavefrontConfig config) { return new Builder(config); } WavefrontMeterRegistry(WavefrontConfig config, Clock clock); @Deprecated WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory); WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory,
WavefrontSender wavefrontSender); static WavefrontClient.Builder getDefaultSenderBuilder(WavefrontConfig config); static Builder builder(WavefrontConfig config); } | @Test void failsWithDefaultSenderWhenUriIsMissing() { WavefrontConfig missingUriConfig = new WavefrontConfig() { @Override public String get(String key) { return null; } @Override public String apiToken() { return "fakeToken"; } }; assertThatExceptionOfType(ValidationException.class) .isThrownBy(() -> WavefrontMeterRegistry.builder(missingUriConfig).build()); }
@Test void failsWithDefaultSenderWhenApiTokenMissingAndDirectToApi() { WavefrontConfig missingApiTokenDirectConfig = WavefrontConfig.DEFAULT_DIRECT; assertThatExceptionOfType(ValidationException.class) .isThrownBy(() -> WavefrontMeterRegistry.builder(missingApiTokenDirectConfig).build()); }
@Test void customSenderDoesNotNeedUri() { WavefrontConfig missingUriConfig = new WavefrontConfig() { @Override public String get(String key) { return null; } @Override public String apiToken() { return "fakeToken"; } }; assertThatCode(() -> WavefrontMeterRegistry.builder(missingUriConfig) .wavefrontSender(mock(WavefrontSender.class)).build()) .doesNotThrowAnyException(); }
@Test void customSenderDoesNotNeedApiToken() { WavefrontConfig missingApiTokenDirectConfig = WavefrontConfig.DEFAULT_DIRECT; assertThatCode(() -> WavefrontMeterRegistry.builder(missingApiTokenDirectConfig) .wavefrontSender(mock(WavefrontSender.class)).build()) .doesNotThrowAnyException(); }
@Test void proxyConfigDoesNotNeedApiToken() { WavefrontConfig missingApiTokenProxyConfig = WavefrontConfig.DEFAULT_PROXY; assertThatCode(() -> WavefrontMeterRegistry.builder(missingApiTokenProxyConfig).build()) .doesNotThrowAnyException(); } |
WavefrontMeterRegistry extends PushMeterRegistry { static String getWavefrontReportingUri(WavefrontConfig wavefrontConfig) { if (!isDirectToApi(wavefrontConfig)) { return "http" + wavefrontConfig.uri().substring("proxy".length()); } return wavefrontConfig.uri(); } WavefrontMeterRegistry(WavefrontConfig config, Clock clock); @Deprecated WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory); WavefrontMeterRegistry(WavefrontConfig config, Clock clock, ThreadFactory threadFactory,
WavefrontSender wavefrontSender); static WavefrontClient.Builder getDefaultSenderBuilder(WavefrontConfig config); static Builder builder(WavefrontConfig config); } | @Test void proxyUriConvertedToHttp() { assertThat(WavefrontMeterRegistry.getWavefrontReportingUri(WavefrontConfig.DEFAULT_PROXY)).startsWith("http: }
@Test void directApiUriUnchanged() { assertThat(WavefrontMeterRegistry.getWavefrontReportingUri(WavefrontConfig.DEFAULT_DIRECT)).isEqualTo(WavefrontConfig.DEFAULT_DIRECT.uri()); } |
GangliaMeterRegistry extends StepMeterRegistry { String getMetricName(Meter.Id id, @Nullable String suffix) { return nameMapper.toHierarchicalName(id.withName(suffix != null ? id.getName() + "." + suffix : id.getName()), config().namingConvention()); } GangliaMeterRegistry(GangliaConfig config, Clock clock); @Deprecated GangliaMeterRegistry(GangliaConfig config, Clock clock, HierarchicalNameMapper nameMapper); private GangliaMeterRegistry(GangliaConfig config, Clock clock, HierarchicalNameMapper nameMapper, ThreadFactory threadFactory); @SuppressWarnings("unused") @Deprecated GangliaMeterRegistry(GangliaConfig config, Clock clock, HierarchicalNameMapper nameMapper, MetricRegistry metricRegistry); static Builder builder(GangliaConfig config); } | @Test void getMetricNameWhenSuffixIsNullShouldNotAppendSuffix() { Meter.Id id = registry.counter("name").getId(); assertThat(registry.getMetricName(id, null)).isEqualTo("name"); }
@Test void getMetricNameWhenSuffixIsNotNullShouldAppendSuffix() { Meter.Id id = registry.counter("name").getId(); assertThat(registry.getMetricName(id, "suffix")).isEqualTo("nameSuffix"); } |
StackdriverNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return sanitize(nameDelegate.name(name, type, baseUnit), NAME_BLACKLIST, MAX_NAME_LENGTH); } StackdriverNamingConvention(); StackdriverNamingConvention(NamingConvention nameDelegate, NamingConvention tagKeyDelegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void name() { assertThat(namingConvention.name("my.counter", Meter.Type.COUNTER)).isEqualTo("my/counter"); } |
StackdriverNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return sanitize(tagKeyDelegate.tagKey(key), TAG_KEY_BLACKLIST, MAX_TAG_KEY_LENGTH); } StackdriverNamingConvention(); StackdriverNamingConvention(NamingConvention nameDelegate, NamingConvention tagKeyDelegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagKey() { assertThat(namingConvention.tagKey("my.tag")).isEqualTo("my_tag"); } |
StackdriverNamingConvention implements NamingConvention { @Override public String tagValue(String value) { return StringUtils.truncate(value, MAX_TAG_VALUE_LENGTH); } StackdriverNamingConvention(); StackdriverNamingConvention(NamingConvention nameDelegate, NamingConvention tagKeyDelegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); } | @Test void tagValue() { assertThat(namingConvention.tagValue("my.tag.value")).isEqualTo("my.tag.value"); }
@Test void tooLongTagValue() { assertThat(namingConvention.tagValue("thisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolong")) .isEqualTo("thisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistoolongthisistool"); } |
AzureMonitorMeterRegistry extends StepMeterRegistry { public static Builder builder(AzureMonitorConfig config) { return new Builder(config); } AzureMonitorMeterRegistry(AzureMonitorConfig config, Clock clock); private AzureMonitorMeterRegistry(AzureMonitorConfig config, Clock clock,
TelemetryConfiguration telemetryConfiguration,
ThreadFactory threadFactory); static Builder builder(AzureMonitorConfig config); @Override void close(); } | @Test void useTelemetryConfigInstrumentationKeyWhenSet() { TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.createDefault(); telemetryConfiguration.setInstrumentationKey("fake"); AzureMonitorMeterRegistry.builder(new AzureMonitorConfig() { @Override public String get(String key) { return null; } @Override public String instrumentationKey() { return "other"; } }).telemetryConfiguration(telemetryConfiguration).build(); assertThat(telemetryConfiguration.getInstrumentationKey()).isEqualTo("fake"); }
@Test void failWhenTelemetryConfigInstrumentationKeyIsUnsetAndConfigInstrumentationKeyIsNull() { TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.createDefault(); assertThatExceptionOfType(ValidationException.class) .isThrownBy(() -> AzureMonitorMeterRegistry.builder(key -> null) .telemetryConfiguration(telemetryConfiguration).build()); } |
AzureMonitorNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { return NAME_AND_TAG_KEY_PATTERN.matcher(delegate.name(name, type, baseUnit)).replaceAll("_"); } AzureMonitorNamingConvention(); AzureMonitorNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); } | @Test void testNameContainsDesiredCharacters() { assertThat(namingConvention.name("{[email protected]}", Type.GAUGE)).isEqualTo("_custom_Metric_1_"); } |
AzureMonitorNamingConvention implements NamingConvention { @Override public String tagKey(String key) { return NAME_AND_TAG_KEY_PATTERN.matcher(delegate.tagKey(key)).replaceAll("_"); } AzureMonitorNamingConvention(); AzureMonitorNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); } | @Test void testTagKeyContainsDesiredCharacters() { assertThat(namingConvention.tagKey("Pc.N@me")).isEqualTo("Pc_N_me"); } |
CloudWatchMeterRegistry extends StepMeterRegistry { List<MetricDatum> metricData() { Batch batch = new Batch(); return getMeters().stream().flatMap(m -> m.match( batch::gaugeData, batch::counterData, batch::timerData, batch::summaryData, batch::longTaskTimerData, batch::timeGaugeData, batch::functionCounterData, batch::functionTimerData, batch::metricData) ).collect(toList()); } CloudWatchMeterRegistry(CloudWatchConfig config, Clock clock,
AmazonCloudWatchAsync amazonCloudWatchAsync); CloudWatchMeterRegistry(CloudWatchConfig config, Clock clock,
AmazonCloudWatchAsync amazonCloudWatchAsync, ThreadFactory threadFactory); } | @Test void metricData() { registry.gauge("gauge", 1d); List<MetricDatum> metricDatumStream = registry.metricData(); assertThat(metricDatumStream.size()).isEqualTo(1); }
@Test void metricDataWhenNaNShouldNotAdd() { registry.gauge("gauge", Double.NaN); AtomicReference<Double> value = new AtomicReference<>(Double.NaN); registry.more().timeGauge("time.gauge", Tags.empty(), value, TimeUnit.MILLISECONDS, AtomicReference::get); List<MetricDatum> metricDatumStream = registry.metricData(); assertThat(metricDatumStream.size()).isEqualTo(0); }
@Test void writeMeterWhenCustomMeterHasOnlyNaNValuesShouldNotBeWritten() { Measurement measurement = new Measurement(() -> Double.NaN, Statistic.VALUE); List<Measurement> measurements = Arrays.asList(measurement); Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.registry); assertThat(registry.new Batch().metricData(meter)).isEmpty(); }
@Test void writeMeterWhenCustomMeterHasMixedNaNAndNonNaNValuesShouldSkipOnlyNaNValues() { Measurement measurement1 = new Measurement(() -> Double.NaN, Statistic.VALUE); Measurement measurement2 = new Measurement(() -> 1d, Statistic.VALUE); Measurement measurement3 = new Measurement(() -> 2d, Statistic.VALUE); List<Measurement> measurements = Arrays.asList(measurement1, measurement2, measurement3); Meter meter = Meter.builder("my.meter", Meter.Type.GAUGE, measurements).register(this.registry); assertThat(registry.new Batch().metricData(meter)).hasSize(2); }
@Test void writeShouldDropTagWithBlankValue() { registry.gauge("my.gauge", Tags.of("accepted", "foo").and("empty", ""), 1d); assertThat(registry.metricData()) .hasSize(1) .allSatisfy(datum -> assertThat(datum.getDimensions()).hasSize(1).contains( new Dimension().withName("accepted").withValue("foo"))); } |
StringUtils { public static String truncate(String string, int maxLength) { if (string.length() > maxLength) { return string.substring(0, maxLength); } return string; } private StringUtils(); static boolean isBlank(@Nullable String string); static boolean isNotBlank(@Nullable String string); static boolean isEmpty(@Nullable String string); static boolean isNotEmpty(@Nullable String string); static String truncate(String string, int maxLength); } | @Test void truncateWhenGreaterThanMaxLengthShouldTruncate() { assertThat(StringUtils.truncate("1234567890", 5)).isEqualTo("12345"); }
@Test void truncateWhenLessThanMaxLengthShouldReturnItself() { assertThat(StringUtils.truncate("123", 5)).isEqualTo("123"); } |
OpenTSDBMeterRegistry extends PushMeterRegistry { Stream<String> writeFunctionCounter(FunctionCounter counter) { double count = counter.count(); if (Double.isFinite(count)) { return Stream.of(writeMetric(counter.getId(), config().clock().wallTime(), count)); } return Stream.empty(); } @SuppressWarnings("deprecation") OpenTSDBMeterRegistry(OpenTSDBConfig config, Clock clock); OpenTSDBMeterRegistry(OpenTSDBConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(OpenTSDBConfig config); @Override Counter newCounter(Meter.Id id); @Override DistributionSummary newDistributionSummary(Meter.Id id, DistributionStatisticConfig distributionStatisticConfig, double scale); } | @Test void writeFunctionCounter() { FunctionCounter counter = FunctionCounter.builder("my.counter", 1d, Number::doubleValue).register(meterRegistry); clock.add(config.step()); assertThat(meterRegistry.writeFunctionCounter(counter)).hasSize(1); } |
StringUtils { public static boolean isNotEmpty(@Nullable String string) { return !isEmpty(string); } private StringUtils(); static boolean isBlank(@Nullable String string); static boolean isNotBlank(@Nullable String string); static boolean isEmpty(@Nullable String string); static boolean isNotEmpty(@Nullable String string); static String truncate(String string, int maxLength); } | @Test void isNotEmptyWhenNullShouldBeFalse() { assertThat(StringUtils.isNotEmpty(null)).isFalse(); }
@Test void isNotEmptyWhenEmptyShouldBeFalse() { assertThat(StringUtils.isNotEmpty("")).isFalse(); }
@Test void isNotEmptyWhenHasAnyCharacterShouldBeFalse() { assertThat(StringUtils.isNotEmpty(" ")).isTrue(); } |
TimeUtils { @Deprecated public static Duration simpleParse(String time) { String timeLower = PARSE_PATTERN.matcher(time.toLowerCase()).replaceAll(""); if (timeLower.endsWith("ns")) { return Duration.ofNanos(Long.parseLong(timeLower.substring(0, timeLower.length() - 2))); } else if (timeLower.endsWith("ms")) { return Duration.ofMillis(Long.parseLong(timeLower.substring(0, timeLower.length() - 2))); } else if (timeLower.endsWith("s")) { return Duration.ofSeconds(Long.parseLong(timeLower.substring(0, timeLower.length() - 1))); } else if (timeLower.endsWith("m")) { return Duration.ofMinutes(Long.parseLong(timeLower.substring(0, timeLower.length() - 1))); } else if (timeLower.endsWith("h")) { return Duration.ofHours(Long.parseLong(timeLower.substring(0, timeLower.length() - 1))); } else if (timeLower.endsWith("d")) { return Duration.of(Long.parseLong(timeLower.substring(0, timeLower.length() - 1)), ChronoUnit.DAYS); } throw new DateTimeParseException("Unable to parse " + time + " into duration", timeLower, 0); } private TimeUtils(); static double convert(double t, TimeUnit sourceUnit, TimeUnit destinationUnit); static double nanosToUnit(double nanos, TimeUnit destinationUnit); static double microsToUnit(double micros, TimeUnit destinationUnit); static double millisToUnit(double millis, TimeUnit destinationUnit); static double secondsToUnit(double seconds, TimeUnit destinationUnit); static double minutesToUnit(double minutes, TimeUnit destinationUnit); static double hoursToUnit(double hours, TimeUnit destinationUnit); static double daysToUnit(double days, TimeUnit destinationUnit); @Deprecated static Duration simpleParse(String time); static String format(Duration duration); } | @Test void simpleParse() { assertThat(TimeUtils.simpleParse("5ns")).isEqualByComparingTo(Duration.ofNanos(5)); assertThat(TimeUtils.simpleParse("700ms")).isEqualByComparingTo(Duration.ofMillis(700)); assertThat(TimeUtils.simpleParse("1s")).isEqualByComparingTo(Duration.ofSeconds(1)); assertThat(TimeUtils.simpleParse("10m")).isEqualByComparingTo(Duration.ofMinutes(10)); assertThat(TimeUtils.simpleParse("13h")).isEqualByComparingTo(Duration.ofHours(13)); assertThat(TimeUtils.simpleParse("5d")).isEqualByComparingTo(Duration.ofDays(5)); }
@Test void simpleParseHandlesSpacesCommasAndUnderscores() { assertThat(TimeUtils.simpleParse("7,000 ms")).isEqualByComparingTo(Duration.ofMillis(7000)); assertThat(TimeUtils.simpleParse("7_000ms ")).isEqualByComparingTo(Duration.ofMillis(7000)); }
@Test void cantParseDecimal() { assertThatThrownBy(() -> TimeUtils.simpleParse("1.1s")) .isInstanceOf(NumberFormatException.class); } |
TimeUtils { public static String format(Duration duration) { return duration.toString() .substring(2) .replaceAll("(\\d[HMS])(?!$)", "$1 ") .toLowerCase(); } private TimeUtils(); static double convert(double t, TimeUnit sourceUnit, TimeUnit destinationUnit); static double nanosToUnit(double nanos, TimeUnit destinationUnit); static double microsToUnit(double micros, TimeUnit destinationUnit); static double millisToUnit(double millis, TimeUnit destinationUnit); static double secondsToUnit(double seconds, TimeUnit destinationUnit); static double minutesToUnit(double minutes, TimeUnit destinationUnit); static double hoursToUnit(double hours, TimeUnit destinationUnit); static double daysToUnit(double days, TimeUnit destinationUnit); @Deprecated static Duration simpleParse(String time); static String format(Duration duration); } | @Test void formatDuration() { assertThat(TimeUtils.format(Duration.ofSeconds(10))).isEqualTo("10s"); assertThat(TimeUtils.format(Duration.ofSeconds(90))).isEqualTo("1m 30s"); assertThat(TimeUtils.format(Duration.ofMinutes(2))).isEqualTo("2m"); assertThat(TimeUtils.format(Duration.ofNanos(1001234000000L))).isEqualTo("16m 41.234s"); } |
StringEscapeUtils { public static String escapeJson(@Nullable String v) { if (v == null) return ""; int length = v.length(); if (length == 0) return v; int afterReplacement = 0; StringBuilder builder = null; for (int i = 0; i < length; i++) { char c = v.charAt(i); String replacement; if (c < 0x80) { replacement = REPLACEMENT_CHARS[c]; if (replacement == null) continue; } else if (c == '\u2028') { replacement = U2028; } else if (c == '\u2029') { replacement = U2029; } else { continue; } if (afterReplacement < i) { if (builder == null) builder = new StringBuilder(length); builder.append(v, afterReplacement, i); } if (builder == null) builder = new StringBuilder(length); builder.append(replacement); afterReplacement = i + 1; } if (builder == null) return v; if (afterReplacement < length) { builder.append(v, afterReplacement, length); } return builder.toString(); } private StringEscapeUtils(); static String escapeJson(@Nullable String v); } | @Test void escapeJsonWhenNullShouldReturnEmptyString() { assertThat(StringEscapeUtils.escapeJson(null)).isEmpty(); }
@Test void escapeJsonWhenEmptyStringShouldReturnEmptyString() { assertThat(StringEscapeUtils.escapeJson("")).isEmpty(); }
@Test void escapeJsonWhenDoubleQuotesShouldReturnEscapedString() { assertThat(StringEscapeUtils.escapeJson("\"Hello, world!\"")).isEqualTo("\\\"Hello, world!\\\""); } |
OpenTSDBNamingConvention implements NamingConvention { @Override public String name(String name, Meter.Type type, @Nullable String baseUnit) { String conventionName = NamingConvention.snakeCase.name(name, type, baseUnit); switch (type) { case COUNTER: case DISTRIBUTION_SUMMARY: case GAUGE: if (baseUnit != null && !conventionName.endsWith("_" + baseUnit)) conventionName += "_" + baseUnit; break; } switch (type) { case COUNTER: if (!conventionName.endsWith("_total")) conventionName += "_total"; break; case TIMER: case LONG_TASK_TIMER: if (conventionName.endsWith(timerSuffix)) { conventionName += "_seconds"; } else if (!conventionName.endsWith("_seconds")) conventionName += timerSuffix + "_seconds"; break; } String sanitized = nameChars.matcher(conventionName).replaceAll(SEPARATOR); if (!Character.isLetter(sanitized.charAt(0))) { sanitized = "m_" + sanitized; } return sanitized; } OpenTSDBNamingConvention(); OpenTSDBNamingConvention(String timerSuffix); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); } | @Test void defaultToSnakeCase() { assertThat(convention.name("gauge.size", Meter.Type.GAUGE)).isEqualTo("gauge_size"); } |
AbstractPartition extends AbstractList<List<T>> { @Override public List<T> get(int index) { int start = index * partitionSize; int end = Math.min(start + partitionSize, delegate.size()); return delegate.subList(start, end); } protected AbstractPartition(List<T> delegate, int partitionSize); @Override List<T> get(int index); @Override int size(); @Override boolean isEmpty(); } | @Test void singlePartitionListActsLikeDelegate_singleElement() { TestPartition singlePartition = new TestPartition(asList("foo"), 1); assertThat(singlePartition).hasSize(1); assertThat(singlePartition.get(0)).containsExactly("foo"); }
@Test void singlePartitionListActsLikeDelegate_multipleElements() { TestPartition singlePartition = new TestPartition(asList("foo", "bar"), 2); assertThat(singlePartition).hasSize(1); assertThat(singlePartition.get(0)).containsExactly("foo", "bar"); }
@Test void lessElementsThanPartitionSize() { TestPartition partition = new TestPartition(asList("foo", "bar"), 3); assertThat(partition).hasSize(1); assertThat(partition.get(0)).containsExactly("foo", "bar"); } |
AbstractPartition extends AbstractList<List<T>> { static <T> int partitionCount(List<T> delegate, int partitionSize) { int result = delegate.size() / partitionSize; return delegate.size() % partitionSize == 0 ? result : result + 1; } protected AbstractPartition(List<T> delegate, int partitionSize); @Override List<T> get(int index); @Override int size(); @Override boolean isEmpty(); } | @Test void partitionCount_roundsUp() { assertThat(partitionCount(asList("foo", "bar", "baz"), 2)) .isEqualTo(2); } |
NamedThreadFactory implements ThreadFactory { @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r); int seq = sequence.getAndIncrement(); thread.setName(prefix + (seq > 1 ? "-" + seq : "")); if (!thread.isDaemon()) thread.setDaemon(true); return thread; } NamedThreadFactory(String prefix); @Override Thread newThread(Runnable r); } | @Test void nameThreads() { NamedThreadFactory threadFactory = new NamedThreadFactory("name"); Runnable body = () -> { }; assertThat(threadFactory.newThread(body).getName()).isEqualTo("name"); assertThat(threadFactory.newThread(body).getName()).isEqualTo("name-2"); } |
IOUtils { public static String toString(@Nullable InputStream inputStream, Charset charset) { if (inputStream == null) return ""; try (StringWriter writer = new StringWriter(); InputStreamReader reader = new InputStreamReader(inputStream, charset); BufferedReader bufferedReader = new BufferedReader(reader)) { char[] chars = new char[DEFAULT_BUFFER_SIZE]; int readChars; while ((readChars = bufferedReader.read(chars)) != EOF) { writer.write(chars, 0, readChars); } return writer.toString(); } catch (IOException ex) { throw new UncheckedIOException(ex); } } private IOUtils(); static String toString(@Nullable InputStream inputStream, Charset charset); static String toString(@Nullable InputStream inputStream); } | @Test void testToString() { String expected = "This is a sample."; ByteArrayInputStream inputStream = new ByteArrayInputStream(expected.getBytes()); assertThat(IOUtils.toString(inputStream)).isEqualTo(expected); }
@Test void testToStringWithCharset() { String expected = "This is a sample."; ByteArrayInputStream inputStream = new ByteArrayInputStream(expected.getBytes(StandardCharsets.UTF_8)); assertThat(IOUtils.toString(inputStream, StandardCharsets.UTF_8)).isEqualTo(expected); } |
DoubleFormat { public static String decimalOrNan(double d) { return DECIMAL_OR_NAN.get().format(d); } private DoubleFormat(); static String decimalOrNan(double d); @Deprecated static String decimalOrWhole(double d); static String decimal(double d); static String wholeOrDecimal(double d); } | @Test void decimalOrNan() { assertThat(DoubleFormat.decimalOrNan(Double.NaN)).isEqualTo("NaN"); assertThat(DoubleFormat.decimalOrNan(123456.1234567)).isEqualTo("123456.123457"); assertThat(DoubleFormat.decimalOrNan(123456)).isEqualTo("123456"); assertThat(DoubleFormat.decimalOrNan(0.123)).isEqualTo("0.123"); } |
DoubleFormat { public static String wholeOrDecimal(double d) { return WHOLE_OR_DECIMAL.get().format(d); } private DoubleFormat(); static String decimalOrNan(double d); @Deprecated static String decimalOrWhole(double d); static String decimal(double d); static String wholeOrDecimal(double d); } | @Test void wholeOrDecimal() { assertThat(DoubleFormat.wholeOrDecimal(123456.1234567)).isEqualTo("123456.123457"); assertThat(DoubleFormat.wholeOrDecimal(1)).isEqualTo("1"); } |
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeTimer(Timer timer) { return Optional.of(writeDocument(timer, builder -> { builder.append(",\"count\":").append(timer.count()); builder.append(",\"sum\":").append(timer.totalTime(getBaseTimeUnit())); builder.append(",\"mean\":").append(timer.mean(getBaseTimeUnit())); builder.append(",\"max\":").append(timer.max(getBaseTimeUnit())); })); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); } | @Test void writeTimer() { Timer timer = Timer.builder("myTimer").register(registry); assertThat(registry.writeTimer(timer)).contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:00:00.001Z\",\"name\":\"myTimer\",\"type\":\"timer\",\"count\":0,\"sum\":0.0,\"mean\":0.0,\"max\":0.0}"); } |
DoubleFormat { public static String decimal(double d) { return DECIMAL.get().format(d); } private DoubleFormat(); static String decimalOrNan(double d); @Deprecated static String decimalOrWhole(double d); static String decimal(double d); static String wholeOrDecimal(double d); } | @Test void decimal() { assertThat(DoubleFormat.decimal(123456.1234567)).isEqualTo("123456.123457"); assertThat(DoubleFormat.decimal(123456)).isEqualTo("123456.0"); assertThat(DoubleFormat.decimal(0.123)).isEqualTo("0.123"); } |
CumulativeFunctionTimer implements FunctionTimer { public double totalTime(TimeUnit unit) { T obj2 = ref.get(); if (obj2 != null) { lastTime = Math.max(TimeUtils.convert(totalTimeFunction.applyAsDouble(obj2), totalTimeFunctionUnit, baseTimeUnit()), 0); } return TimeUtils.convert(lastTime, baseTimeUnit(), unit); } CumulativeFunctionTimer(Id id, T obj, ToLongFunction<T> countFunction, ToDoubleFunction<T> totalTimeFunction,
TimeUnit totalTimeFunctionUnit, TimeUnit baseTimeUnit); double count(); double totalTime(TimeUnit unit); @Override Id getId(); @Override TimeUnit baseTimeUnit(); Type type(); } | @Test void totalTimeWhenStateObjectChangedToNullShouldWorkWithChangedTimeUnit() { CumulativeFunctionTimer<Object> functionTimer = new CumulativeFunctionTimer<>( null, new Object(), (o) -> 1L, (o) -> 1d, TimeUnit.SECONDS, TimeUnit.SECONDS); assertThat(functionTimer.totalTime(TimeUnit.SECONDS)).isEqualTo(1d); assertThat(functionTimer.totalTime(TimeUnit.MILLISECONDS)).isEqualTo(1000d); System.gc(); assertThat(functionTimer.totalTime(TimeUnit.MILLISECONDS)).isEqualTo(1000d); assertThat(functionTimer.totalTime(TimeUnit.SECONDS)).isEqualTo(1d); } |
MeterRegistry { @Incubating(since = "1.2.0") public void clear() { meterMap.keySet().forEach(this::remove); } protected MeterRegistry(Clock clock); List<Meter> getMeters(); void forEachMeter(Consumer<? super Meter> consumer); Config config(); Search find(String name); RequiredSearch get(String name); Counter counter(String name, Iterable<Tag> tags); Counter counter(String name, String... tags); DistributionSummary summary(String name, Iterable<Tag> tags); DistributionSummary summary(String name, String... tags); Timer timer(String name, Iterable<Tag> tags); Timer timer(String name, String... tags); More more(); @Nullable T gauge(String name, Iterable<Tag> tags, @Nullable T stateObject, ToDoubleFunction<T> valueFunction); @Nullable T gauge(String name, Iterable<Tag> tags, T number); @Nullable T gauge(String name, T number); @Nullable T gauge(String name, T stateObject, ToDoubleFunction<T> valueFunction); @Nullable T gaugeCollectionSize(String name, Iterable<Tag> tags, T collection); @Nullable T gaugeMapSize(String name, Iterable<Tag> tags, T map); @Incubating(since = "1.1.0") @Nullable Meter remove(Meter meter); @Incubating(since = "1.1.0") @Nullable Meter remove(Meter.Id mappedId); @Incubating(since = "1.2.0") void clear(); void close(); boolean isClosed(); } | @Test void clear() { registry.counter("my.counter"); registry.counter("my.counter2"); assertThat(registry.find("my.counter").counter()).isNotNull(); assertThat(registry.find("my.counter2").counter()).isNotNull(); registry.clear(); assertThat(registry.find("my.counter").counter()).isNull(); assertThat(registry.find("my.counter2").counter()).isNull(); } |
SimpleMeterRegistry extends MeterRegistry { @Override protected <T> FunctionTimer newFunctionTimer(Meter.Id id, T obj, ToLongFunction<T> countFunction, ToDoubleFunction<T> totalTimeFunction, TimeUnit totalTimeFunctionUnit) { switch (config.mode()) { case CUMULATIVE: return new CumulativeFunctionTimer<>(id, obj, countFunction, totalTimeFunction, totalTimeFunctionUnit, getBaseTimeUnit()); case STEP: default: return new StepFunctionTimer<>(id, clock, config.step().toMillis(), obj, countFunction, totalTimeFunction, totalTimeFunctionUnit, getBaseTimeUnit()); } } SimpleMeterRegistry(); SimpleMeterRegistry(SimpleConfig config, Clock clock); } | @Test void newFunctionTimerWhenCountingModeIsCumulativeShouldReturnCumulativeFunctionTimer() { SimpleMeterRegistry registry = createRegistry(CountingMode.CUMULATIVE); Meter.Id id = new Meter.Id("some.timer", Tags.empty(), null, null, Meter.Type.TIMER); FunctionTimer functionTimer = registry.newFunctionTimer(id, null, (o) -> 0L, (o) -> 0d, TimeUnit.SECONDS); assertThat(functionTimer).isInstanceOf(CumulativeFunctionTimer.class); }
@Test void newFunctionTimerWhenCountingModeIsStepShouldReturnStepFunctionTimer() { SimpleMeterRegistry registry = createRegistry(CountingMode.STEP); Meter.Id id = new Meter.Id("some.timer", Tags.empty(), null, null, Meter.Type.TIMER); FunctionTimer functionTimer = registry.newFunctionTimer(id, null, (o) -> 0L, (o) -> 0d, TimeUnit.SECONDS); assertThat(functionTimer).isInstanceOf(StepFunctionTimer.class); } |
SimpleMeterRegistry extends MeterRegistry { @Override protected <T> FunctionCounter newFunctionCounter(Meter.Id id, T obj, ToDoubleFunction<T> countFunction) { switch (config.mode()) { case CUMULATIVE: return new CumulativeFunctionCounter<>(id, obj, countFunction); case STEP: default: return new StepFunctionCounter<>(id, clock, config.step().toMillis(), obj, countFunction); } } SimpleMeterRegistry(); SimpleMeterRegistry(SimpleConfig config, Clock clock); } | @Test void newFunctionCounterWhenCountingModeIsCumulativeShouldReturnCumulativeFunctionCounter() { SimpleMeterRegistry registry = createRegistry(CountingMode.CUMULATIVE); Meter.Id id = new Meter.Id("some.timer", Tags.empty(), null, null, Meter.Type.COUNTER); FunctionCounter functionCounter = registry.newFunctionCounter(id, null, (o) -> 0d); assertThat(functionCounter).isInstanceOf(CumulativeFunctionCounter.class); }
@Test void newFunctionCounterWhenCountingModeIsStepShouldReturnStepFunctionCounter() { SimpleMeterRegistry registry = createRegistry(CountingMode.STEP); Meter.Id id = new Meter.Id("some.timer", Tags.empty(), null, null, Meter.Type.COUNTER); FunctionCounter functionCounter = registry.newFunctionCounter(id, null, (o) -> 0d); assertThat(functionCounter).isInstanceOf(StepFunctionCounter.class); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.