target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void testDoubleAverage() { Average avg = new Average(); avg.add(2.0D); avg.add(4.0D); avg.add(4.0D); Assert.assertEquals(3.3333333333333335D, avg.toDouble(), 0); Assert.assertEquals(3.3333333333333335D, avg.toDouble(), 0); } | public void add(Long input) { count++; final long longAvgUntilNow = toLong(); setLongValue(toLong() + ((input + longRemainder - longAvgUntilNow) / count)); longRemainder = (input + longRemainder - longAvgUntilNow) % count; } | Average extends AbstractRollupStat { public void add(Long input) { count++; final long longAvgUntilNow = toLong(); setLongValue(toLong() + ((input + longRemainder - longAvgUntilNow) / count)); longRemainder = (input + longRemainder - longAvgUntilNow) % count; } } | Average extends AbstractRollupStat { public void add(Long input) { count++; final long longAvgUntilNow = toLong(); setLongValue(toLong() + ((input + longRemainder - longAvgUntilNow) / count)); longRemainder = (input + longRemainder - longAvgUntilNow) % count; } Average(); @SuppressWarnings("unused") // used by Jackson Average(long value); @SuppressWarnings("unused") // used by Jackson Average(double value); Average(int count, Object value); } | Average extends AbstractRollupStat { public void add(Long input) { count++; final long longAvgUntilNow = toLong(); setLongValue(toLong() + ((input + longRemainder - longAvgUntilNow) / count)); longRemainder = (input + longRemainder - longAvgUntilNow) % count; } Average(); @SuppressWarnings("unused") // used by Jackson Average(long value); @SuppressWarnings("unused") // used by Jackson Average(double value); Average(int count, Object value); void add(Long input); void addBatch(Long input, long dataPoints); void add(Double input); void addBatch(Double input, long dataPoints); @Override byte getStatType(); } | Average extends AbstractRollupStat { public void add(Long input) { count++; final long longAvgUntilNow = toLong(); setLongValue(toLong() + ((input + longRemainder - longAvgUntilNow) / count)); longRemainder = (input + longRemainder - longAvgUntilNow) % count; } Average(); @SuppressWarnings("unused") // used by Jackson Average(long value); @SuppressWarnings("unused") // used by Jackson Average(double value); Average(int count, Object value); void add(Long input); void addBatch(Long input, long dataPoints); void add(Double input); void addBatch(Double input, long dataPoints); @Override byte getStatType(); } |
@Test public void getManagedShardsGetsCollectionFromManager() { HashSet<Integer> managedShards = new HashSet<Integer>(); managedShards.add(0); managedShards.add(1); managedShards.add(2); doReturn(managedShards).when(shardStateManager).getManagedShards(); Collection<Integer> actual = service.getManagedShards(); assertEquals(managedShards.size(), actual.size()); assertTrue(actual.containsAll(managedShards)); verify(shardStateManager).getManagedShards(); verifyNoMoreInteractions(shardStateManager); } | public Collection<Integer> getManagedShards() { return new TreeSet<Integer>(shardStateManager.getManagedShards()); } | RollupService implements Runnable, RollupServiceMBean { public Collection<Integer> getManagedShards() { return new TreeSet<Integer>(shardStateManager.getManagedShards()); } } | RollupService implements Runnable, RollupServiceMBean { public Collection<Integer> getManagedShards() { return new TreeSet<Integer>(shardStateManager.getManagedShards()); } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); } | RollupService implements Runnable, RollupServiceMBean { public Collection<Integer> getManagedShards() { return new TreeSet<Integer>(shardStateManager.getManagedShards()); } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | RollupService implements Runnable, RollupServiceMBean { public Collection<Integer> getManagedShards() { return new TreeSet<Integer>(shardStateManager.getManagedShards()); } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } |
@Test public void equalsOtherNullReturnsFalse() { BluefloodCounterRollup rollup = new BluefloodCounterRollup(); assertFalse(rollup.equals(null)); } | @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } | BluefloodCounterRollup implements Rollup { @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } } | BluefloodCounterRollup implements Rollup { @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } BluefloodCounterRollup(); } | BluefloodCounterRollup implements Rollup { @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } | BluefloodCounterRollup implements Rollup { @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } |
@Test public void equalsOtherNotRollupReturnsFalse() { BluefloodCounterRollup rollup = new BluefloodCounterRollup(); assertFalse(rollup.equals("")); } | @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } | BluefloodCounterRollup implements Rollup { @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } } | BluefloodCounterRollup implements Rollup { @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } BluefloodCounterRollup(); } | BluefloodCounterRollup implements Rollup { @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } | BluefloodCounterRollup implements Rollup { @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } |
@Test(expected = NullPointerException.class) public void rawSampleBuilderWithNullInputsThrowsException() throws IOException { BluefloodCounterRollup rollup = BluefloodCounterRollup.buildRollupFromRawSamples(null); } | public static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input) throws IOException { long minTime = Long.MAX_VALUE; long maxTime = Long.MIN_VALUE; BluefloodCounterRollup rollup = new BluefloodCounterRollup(); Number count = 0L; for (Points.Point<SimpleNumber> point : input.getPoints().values()) { count = sum(count, point.getData().getValue()); minTime = Math.min(minTime, point.getTimestamp()); maxTime = Math.max(maxTime, point.getTimestamp()); } double numSeconds = (double)(maxTime - minTime); double rate = count.doubleValue() / numSeconds; return rollup.withCount(count).withRate(rate).withSampleCount(input.getPoints().size()); } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input) throws IOException { long minTime = Long.MAX_VALUE; long maxTime = Long.MIN_VALUE; BluefloodCounterRollup rollup = new BluefloodCounterRollup(); Number count = 0L; for (Points.Point<SimpleNumber> point : input.getPoints().values()) { count = sum(count, point.getData().getValue()); minTime = Math.min(minTime, point.getTimestamp()); maxTime = Math.max(maxTime, point.getTimestamp()); } double numSeconds = (double)(maxTime - minTime); double rate = count.doubleValue() / numSeconds; return rollup.withCount(count).withRate(rate).withSampleCount(input.getPoints().size()); } } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input) throws IOException { long minTime = Long.MAX_VALUE; long maxTime = Long.MIN_VALUE; BluefloodCounterRollup rollup = new BluefloodCounterRollup(); Number count = 0L; for (Points.Point<SimpleNumber> point : input.getPoints().values()) { count = sum(count, point.getData().getValue()); minTime = Math.min(minTime, point.getTimestamp()); maxTime = Math.max(maxTime, point.getTimestamp()); } double numSeconds = (double)(maxTime - minTime); double rate = count.doubleValue() / numSeconds; return rollup.withCount(count).withRate(rate).withSampleCount(input.getPoints().size()); } BluefloodCounterRollup(); } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input) throws IOException { long minTime = Long.MAX_VALUE; long maxTime = Long.MIN_VALUE; BluefloodCounterRollup rollup = new BluefloodCounterRollup(); Number count = 0L; for (Points.Point<SimpleNumber> point : input.getPoints().values()) { count = sum(count, point.getData().getValue()); minTime = Math.min(minTime, point.getTimestamp()); maxTime = Math.max(maxTime, point.getTimestamp()); } double numSeconds = (double)(maxTime - minTime); double rate = count.doubleValue() / numSeconds; return rollup.withCount(count).withRate(rate).withSampleCount(input.getPoints().size()); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input) throws IOException { long minTime = Long.MAX_VALUE; long maxTime = Long.MIN_VALUE; BluefloodCounterRollup rollup = new BluefloodCounterRollup(); Number count = 0L; for (Points.Point<SimpleNumber> point : input.getPoints().values()) { count = sum(count, point.getData().getValue()); minTime = Math.min(minTime, point.getTimestamp()); maxTime = Math.max(maxTime, point.getTimestamp()); } double numSeconds = (double)(maxTime - minTime); double rate = count.doubleValue() / numSeconds; return rollup.withCount(count).withRate(rate).withSampleCount(input.getPoints().size()); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } |
@Test(expected = NullPointerException.class) public void counterRollupBuilderWithNullRollupInputThrowsException() throws IOException { Points<BluefloodCounterRollup> combined = new Points<BluefloodCounterRollup>(); combined.add(new Points.Point<BluefloodCounterRollup>(1234L, null)); BluefloodCounterRollup rollup = BluefloodCounterRollup.buildRollupFromCounterRollups(combined); } | public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } BluefloodCounterRollup(); } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } |
@Test(expected = NullPointerException.class) public void counterRollupBuilderWithNullCombinedInputThrowsException() throws IOException { BluefloodCounterRollup rollup = BluefloodCounterRollup.buildRollupFromCounterRollups(null); } | public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } BluefloodCounterRollup(); } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } | BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } |
@Test public void getRollupTypeReturnsCounter() { BluefloodCounterRollup rollup = new BluefloodCounterRollup(); assertEquals(RollupType.COUNTER, rollup.getRollupType()); } | @Override public RollupType getRollupType() { return RollupType.COUNTER; } | BluefloodCounterRollup implements Rollup { @Override public RollupType getRollupType() { return RollupType.COUNTER; } } | BluefloodCounterRollup implements Rollup { @Override public RollupType getRollupType() { return RollupType.COUNTER; } BluefloodCounterRollup(); } | BluefloodCounterRollup implements Rollup { @Override public RollupType getRollupType() { return RollupType.COUNTER; } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } | BluefloodCounterRollup implements Rollup { @Override public RollupType getRollupType() { return RollupType.COUNTER; } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } |
@Test public void testConvertToMap() { Map<String, Object> properties = event.toMap(); Assert.assertEquals(properties.get(Event.FieldLabels.when.name()), 1L); Assert.assertEquals(properties.get(Event.FieldLabels.data.name()), "2"); Assert.assertEquals(properties.get(Event.FieldLabels.tags.name()), "3"); Assert.assertEquals(properties.get(Event.FieldLabels.what.name()), "4"); } | public Map<String, Object> toMap() { return new HashMap<String, Object>() { { put(FieldLabels.when.name(), getWhen()); put(FieldLabels.what.name(), getWhat()); put(FieldLabels.data.name(), getData()); put(FieldLabels.tags.name(), getTags()); } }; } | Event { public Map<String, Object> toMap() { return new HashMap<String, Object>() { { put(FieldLabels.when.name(), getWhen()); put(FieldLabels.what.name(), getWhat()); put(FieldLabels.data.name(), getData()); put(FieldLabels.tags.name(), getTags()); } }; } } | Event { public Map<String, Object> toMap() { return new HashMap<String, Object>() { { put(FieldLabels.when.name(), getWhen()); put(FieldLabels.what.name(), getWhat()); put(FieldLabels.data.name(), getData()); put(FieldLabels.tags.name(), getTags()); } }; } Event(); @VisibleForTesting Event(long when, String what); } | Event { public Map<String, Object> toMap() { return new HashMap<String, Object>() { { put(FieldLabels.when.name(), getWhen()); put(FieldLabels.what.name(), getWhat()); put(FieldLabels.data.name(), getData()); put(FieldLabels.tags.name(), getTags()); } }; } Event(); @VisibleForTesting Event(long when, String what); Map<String, Object> toMap(); long getWhen(); void setWhen(long when); String getWhat(); void setWhat(String what); String getData(); void setData(String data); String getTags(); void setTags(String tags); } | Event { public Map<String, Object> toMap() { return new HashMap<String, Object>() { { put(FieldLabels.when.name(), getWhen()); put(FieldLabels.what.name(), getWhat()); put(FieldLabels.data.name(), getData()); put(FieldLabels.tags.name(), getTags()); } }; } Event(); @VisibleForTesting Event(long when, String what); Map<String, Object> toMap(); long getWhen(); void setWhen(long when); String getWhat(); void setWhat(String what); String getData(); void setData(String data); String getTags(); void setTags(String tags); static final String untilParameterName; static final String fromParameterName; static final String tagsParameterName; } |
@Test public void testGetIndexesToSearch() throws IOException { String[] indices = elasticTokensIO.getIndexesToSearch(); assertEquals(1, indices.length); assertEquals("metric_tokens", indices[0]); } | protected String[] getIndexesToSearch() { return new String[] {ELASTICSEARCH_TOKEN_INDEX_NAME_READ}; } | ElasticTokensIO implements TokenDiscoveryIO { protected String[] getIndexesToSearch() { return new String[] {ELASTICSEARCH_TOKEN_INDEX_NAME_READ}; } } | ElasticTokensIO implements TokenDiscoveryIO { protected String[] getIndexesToSearch() { return new String[] {ELASTICSEARCH_TOKEN_INDEX_NAME_READ}; } ElasticTokensIO(); } | ElasticTokensIO implements TokenDiscoveryIO { protected String[] getIndexesToSearch() { return new String[] {ELASTICSEARCH_TOKEN_INDEX_NAME_READ}; } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); } | ElasticTokensIO implements TokenDiscoveryIO { protected String[] getIndexesToSearch() { return new String[] {ELASTICSEARCH_TOKEN_INDEX_NAME_READ}; } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); static final String ES_DOCUMENT_TYPE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_WRITE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_READ; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testRegexLevel0() { List<String> terms = Arrays.asList("", "foo", "bar", "b", "foo.bar", "foo.bar.baz", "foo.bar.baz.aux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(3, matchingTerms.size()); assertEquals("foo", matchingTerms.get(0)); assertEquals("bar", matchingTerms.get(1)); assertEquals("b", matchingTerms.get(2)); } | protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); static final String ES_DOCUMENT_TYPE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_WRITE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_READ; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testRegexLevel0WildCard() { List<String> terms = Arrays.asList("", "foo", "bar", "baz", "b", "foo.bar", "foo.bar.baz", "foo.bar.baz.aux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("b*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(3, matchingTerms.size()); assertEquals("bar", matchingTerms.get(0)); assertEquals("baz", matchingTerms.get(1)); assertEquals("b", matchingTerms.get(2)); } | protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); static final String ES_DOCUMENT_TYPE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_WRITE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_READ; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void getRecentlyScheduledShardsGetsFromContext() { Collection<Integer> recent = service.getRecentlyScheduledShards(); assertNotNull(recent); verify(context).getRecentlyScheduledShards(); verifyNoMoreInteractions(context); verifyZeroInteractions(shardStateManager); } | public synchronized Collection<Integer> getRecentlyScheduledShards() { return context.getRecentlyScheduledShards(); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<Integer> getRecentlyScheduledShards() { return context.getRecentlyScheduledShards(); } } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<Integer> getRecentlyScheduledShards() { return context.getRecentlyScheduledShards(); } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<Integer> getRecentlyScheduledShards() { return context.getRecentlyScheduledShards(); } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<Integer> getRecentlyScheduledShards() { return context.getRecentlyScheduledShards(); } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } |
@Test public void testRegexLevel1() { List<String> terms = Arrays.asList("foo", "bar", "baz", "foo.bar", "foo.b", "foo.xxx", "foo.bar.baz", "foo.bar.baz.aux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("foo.*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(3, matchingTerms.size()); assertEquals("foo.bar", matchingTerms.get(0)); assertEquals("foo.b", matchingTerms.get(1)); assertEquals("foo.xxx", matchingTerms.get(2)); } | protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); static final String ES_DOCUMENT_TYPE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_WRITE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_READ; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testRegexLevel1WildCard() { List<String> terms = Arrays.asList("foo", "bar", "baz", "foo.bar", "foo.b", "foo.xxx", "foo.bar.baz", "foo.bar.baz.aux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("foo.b*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(2, matchingTerms.size()); assertEquals("foo.bar", matchingTerms.get(0)); assertEquals("foo.b", matchingTerms.get(1)); } | protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); static final String ES_DOCUMENT_TYPE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_WRITE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_READ; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testRegexLevel2() { List<String> terms = Arrays.asList("foo", "bar", "baz", "foo.bar", "foo.bar.baz", "foo.bar.baz.qux", "foo.bar.baz.qux.quux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("foo.bar.*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(1, matchingTerms.size()); assertEquals("foo.bar.baz", matchingTerms.get(0)); } | protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); static final String ES_DOCUMENT_TYPE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_WRITE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_READ; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testRegexLevel3() { List<String> terms = Arrays.asList("foo", "bar", "baz", "foo.bar", "foo.bar.baz", "foo.bar.baz.qux", "foo.bar.baz.qux.quux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("foo.bar.baz.*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(1, matchingTerms.size()); assertEquals("foo.bar.baz.qux", matchingTerms.get(0)); } | protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); } | ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); static final String ES_DOCUMENT_TYPE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_WRITE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_READ; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testNonCrossTenantSearch() throws Exception { Map<String, List<String>> query = new HashMap<>(); query.put(Event.tagsParameterName, Arrays.asList("event")); List<Map<String, Object>> results = searchIO.search(TENANT_1, query); Assert.assertEquals(TENANT_1_EVENTS_NUM, results.size()); results = searchIO.search(TENANT_2, query); Assert.assertEquals(TENANT_2_EVENTS_NUM, results.size()); results = searchIO.search(TENANT_RANGE, query); Assert.assertEquals(TENANT_RANGE_EVENTS_NUM, results.size()); results = searchIO.search(TENANT_WITH_SYMBOLS, query); Assert.assertEquals(TENANT_WITH_SYMBOLS_NUM, results.size()); } | @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); static final String EVENT_INDEX; static final String ES_TYPE; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testEmptyQueryParameters() throws Exception { Map<String, List<String>> query = new HashMap<>(); query.put(Event.tagsParameterName, new ArrayList<>()); query.put(Event.fromParameterName, new ArrayList<>()); query.put(Event.untilParameterName, new ArrayList<>()); List<Map<String, Object>> results = searchIO.search(TENANT_1, query); Assert.assertEquals(TENANT_1_EVENTS_NUM, results.size()); } | @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); static final String EVENT_INDEX; static final String ES_TYPE; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testEventTagsOnlySearch() throws Exception { Map<String, List<String>> query = new HashMap<>(); query.put(Event.tagsParameterName, Arrays.asList("sample")); List<Map<String, Object>> results = searchIO.search(TENANT_1, query); Assert.assertEquals(TENANT_1_EVENTS_NUM, results.size()); query.put(Event.tagsParameterName, Arrays.asList("1")); results = searchIO.search(TENANT_1, query); Assert.assertEquals(1, results.size()); query.put(Event.tagsParameterName, Arrays.asList("database")); results = searchIO.search(TENANT_1, query); Assert.assertEquals(0, results.size()); } | @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); static final String EVENT_INDEX; static final String ES_TYPE; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testEmptyQuery() throws Exception { List<Map<String, Object>> results = searchIO.search(TENANT_1, null); Assert.assertEquals(TENANT_1_EVENTS_NUM, results.size()); } | @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); static final String EVENT_INDEX; static final String ES_TYPE; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testRangeOnlySearch() throws Exception { Map<String, List<String>> query = new HashMap<>(); final int eventCountToCapture = TENANT_RANGE_EVENTS_NUM / 2; final int secondsDelta = 10; DateTime fromDateTime = new DateTime().minusSeconds(RANGE_STEP_IN_SECONDS * eventCountToCapture - secondsDelta); query.put(Event.fromParameterName, Arrays.asList(Long.toString(fromDateTime.getMillis()))); List<Map<String, Object>> results = searchIO.search(TENANT_RANGE, query); Assert.assertEquals(eventCountToCapture, results.size()); DateTime untilDateTime = new DateTime().minusSeconds(RANGE_STEP_IN_SECONDS * eventCountToCapture - secondsDelta); query.clear(); query.put(Event.untilParameterName, Arrays.asList(Long.toString(untilDateTime.getMillis()))); results = searchIO.search(TENANT_RANGE, query); Assert.assertEquals(eventCountToCapture, results.size()); query.clear(); fromDateTime = new DateTime().minusSeconds(RANGE_STEP_IN_SECONDS * 2 - secondsDelta); untilDateTime = new DateTime().minusSeconds(RANGE_STEP_IN_SECONDS - secondsDelta); query.put(Event.fromParameterName, Arrays.asList(Long.toString(fromDateTime.getMillis()))); query.put(Event.untilParameterName, Arrays.asList(Long.toString(untilDateTime.getMillis()))); results = searchIO.search(TENANT_RANGE, query); Assert.assertEquals(1, results.size()); } | @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); } | EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); static final String EVENT_INDEX; static final String ES_TYPE; public ElasticsearchRestHelper elasticsearchRestHelper; } |
@Test public void testMetricIndexesBuilderSingleMetricName() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar|1"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); } | public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } |
@Test public void getOldestWithNullStampsReturnsEmptyCollection() { doReturn(null).when(context).getSlotStamps(Matchers.<Granularity>any(), anyInt()); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(0, result.size()); } | public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } |
@Test public void testMetricIndexesBuilderSingleMetricNameSecondTokenQuery() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.qux"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo.*"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar|1"); add("foo.bar.baz|1"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); } | public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } |
@Test (expected = IllegalArgumentException.class) public void testMetricIndexesBuilderSingleMetricName1() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo"); }}; buildMetricIndexesSimilarToES(metricNames, ""); } | public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } |
@Test public void testMetricIndexesBuilderLongMetrics() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.qux.x.y"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo.bar"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar|1"); add("foo.bar.baz|1"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); } | public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } |
@Test public void testMetricIndexesBuilderLongMetricsWildcard() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.qux.x.y"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo.bar.*"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar.baz|1"); add("foo.bar.baz.qux|1"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); } | public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } |
@Test public void testMetricIndexesBuilderMultipleMetrics() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.qux.x"); add("foo.bar.baz.qux"); add("foo.bar.baz"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo.bar.*"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar.baz|3"); add("foo.bar.baz.qux|2"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); } | public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } |
@Test public void testSingleLevelQueryMultipleMetrics() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.x.y.z"); add("foo.bar"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar|2"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); } | public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } |
@Test public void testSingleLevelWildcardQueryMultipleMetrics() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.x.y.z"); add("moo.bar"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "*"); Set<String> expectedIndexes = new HashSet<String>() {{ add("moo.bar|1"); add("foo.bar|1"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); } | public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } | MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } |
@Test public void contentTypeEmptyShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.CONTENT_TYPE)).thenReturn(""); assertTrue("empty content-type should be valid", mediaTypeChecker.isContentTypeValid(mockHeaders)); } | public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } |
@Test public void contentTypeJsonShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.CONTENT_TYPE)).thenReturn("application/json"); assertTrue("content-type application/json should be valid", mediaTypeChecker.isContentTypeValid(mockHeaders)); } | public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } |
@Test public void contentTypeJsonMixedCaseShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.CONTENT_TYPE)).thenReturn("aPpLiCaTiOn/JSON"); assertTrue("content-type aPpLiCaTiOn/JSON should be valid", mediaTypeChecker.isContentTypeValid(mockHeaders)); } | public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } |
@Test public void getOldestWithEmptyStampsReturnsEmptyCollection() { HashMap<Integer, UpdateStamp> empty = new HashMap<Integer, UpdateStamp>(); doReturn(empty).when(context).getSlotStamps(Matchers.<Granularity>any(), anyInt()); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(0, result.size()); } | public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } |
@Test public void contentTypeJsonWithCharsetShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.CONTENT_TYPE)).thenReturn("application/json; charset=wtf-8"); assertTrue("content-type application/json should be valid", mediaTypeChecker.isContentTypeValid(mockHeaders)); } | public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } |
@Test public void contentTypePdfShouldBeInvalid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.CONTENT_TYPE)).thenReturn("application/pdf"); assertFalse("content-type application/pdf should be invalid", mediaTypeChecker.isContentTypeValid(mockHeaders)); } | public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } |
@Test public void acceptEmptyShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.ACCEPT)).thenReturn(""); assertTrue("empty accept should be valid", mediaTypeChecker.isAcceptValid(mockHeaders)); } | public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } |
@Test public void acceptAllShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.ACCEPT)).thenReturn("** should be valid", mediaTypeChecker.isAcceptValid(mockHeaders)); } | public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } |
@Test public void acceptJsonShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.ACCEPT)).thenReturn("application/json"); assertTrue("accept application/json should be valid", mediaTypeChecker.isAcceptValid(mockHeaders)); } | public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } |
@Test public void acceptAllWithCharsetQualityShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.ACCEPT)).thenReturn("text/html,application/xhtml+xml,application/xml;q=0.9,**;q=0.8 should be valid", mediaTypeChecker.isAcceptValid(mockHeaders)); } | public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } |
@Test public void acceptXmlShouldBeInvalid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.ACCEPT)).thenReturn("text/html,application/xhtml+xml,application/xml;q=0.9"); assertFalse("accept text/html,application/xhtml+xml,application/xml;q=0.9 should be invalid", mediaTypeChecker.isAcceptValid(mockHeaders)); } | public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } |
@Test public void testDefaultHttpConnIdleTimeout_RequestKeepAlive_ShouldHaveResponseKeepAlive() { HttpResponder responder = new HttpResponder(); ChannelHandlerContext ctx = mock(ChannelHandlerContext.class); FullHttpRequest request = mock(FullHttpRequest.class); FullHttpResponse response = mock(FullHttpResponse.class); HttpHeaders headers = mock(HttpHeaders.class); Channel channel = mock(Channel.class); when(ctx.channel()).thenReturn(channel); when(request.content()).thenReturn(null); when(request.headers()).thenReturn(headers); when(headers.get(HttpHeaders.Names.CONNECTION)).thenReturn(HttpHeaders.Values.KEEP_ALIVE); when(request.getProtocolVersion()).thenReturn(HttpVersion.HTTP_1_1); HttpHeaders responseHeaders = new DefaultHttpHeaders(); when(response.headers()).thenReturn(responseHeaders); responder.respond(ctx, request, response); assertEquals("Connection: response header", HttpHeaders.Values.KEEP_ALIVE, responseHeaders.get(HttpHeaders.Names.CONNECTION)); } | public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } | HttpResponder { public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } } | HttpResponder { public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } @VisibleForTesting HttpResponder(); @VisibleForTesting HttpResponder(int httpConnIdleTimeout); } | HttpResponder { public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } @VisibleForTesting HttpResponder(); @VisibleForTesting HttpResponder(int httpConnIdleTimeout); static HttpResponder getInstance(); void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status); void respond(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse res); } | HttpResponder { public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } @VisibleForTesting HttpResponder(); @VisibleForTesting HttpResponder(int httpConnIdleTimeout); static HttpResponder getInstance(); void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status); void respond(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse res); } |
@Test public void testNonZeroHttpConnIdleTimeout_RequestKeepAlive_ShouldHaveResponseKeepAliveTimeout() { int idleTimeout = 300; HttpResponder responder = new HttpResponder(idleTimeout); ChannelHandlerContext ctx = mock(ChannelHandlerContext.class); FullHttpRequest request = mock(FullHttpRequest.class); FullHttpResponse response = mock(FullHttpResponse.class); HttpHeaders headers = mock(HttpHeaders.class); Channel channel = mock(Channel.class); ChannelFuture future = mock(ChannelFuture.class); when(ctx.channel()).thenReturn(channel); when(ctx.writeAndFlush(any())).thenReturn(future); when(request.content()).thenReturn(null); when(request.headers()).thenReturn(headers); when(headers.get(HttpHeaders.Names.CONNECTION)).thenReturn(HttpHeaders.Values.KEEP_ALIVE); when(request.getProtocolVersion()).thenReturn(HttpVersion.HTTP_1_1); HttpHeaders responseHeaders = new DefaultHttpHeaders(); when(response.headers()).thenReturn(responseHeaders); responder.respond(ctx, request, response); assertEquals("Connection: response header", HttpHeaders.Values.KEEP_ALIVE, responseHeaders.get(HttpHeaders.Names.CONNECTION)); assertEquals("Keep-Alive: response header", "timeout="+idleTimeout, responseHeaders.get("Keep-Alive")); } | public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } | HttpResponder { public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } } | HttpResponder { public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } @VisibleForTesting HttpResponder(); @VisibleForTesting HttpResponder(int httpConnIdleTimeout); } | HttpResponder { public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } @VisibleForTesting HttpResponder(); @VisibleForTesting HttpResponder(int httpConnIdleTimeout); static HttpResponder getInstance(); void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status); void respond(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse res); } | HttpResponder { public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } @VisibleForTesting HttpResponder(); @VisibleForTesting HttpResponder(int httpConnIdleTimeout); static HttpResponder getInstance(); void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status); void respond(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse res); } |
@Test public void testValidRoutePatterns() throws Exception { FullHttpRequest modifiedReq = testPattern("/metrics/:metricId", "/metrics/foo"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(1, modifiedReq.headers().names().size()); Assert.assertEquals("metricId", modifiedReq.headers().entries().get(0).getKey()); Assert.assertEquals("foo", modifiedReq.headers().entries().get(0).getValue()); testRouteHandlerCalled = false; modifiedReq = testPattern("/tenants/:tenantId/entities/:entityId", "/tenants/acFoo/entities/enBar"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(2, modifiedReq.headers().names().size()); Assert.assertTrue(modifiedReq.headers().get("tenantId").equals("acFoo")); Assert.assertTrue(modifiedReq.headers().get("entityId").equals("enBar")); testRouteHandlerCalled = false; modifiedReq = testPattern("/tenants/:tenantId/entities/:entityId/checks/:checkId/metrics/:metricId/plot", "/tenants/acFoo/entities/enBar/checks/chFoo/metrics/myMetric/plot"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(4, modifiedReq.headers().names().size()); Assert.assertTrue(modifiedReq.headers().get("tenantId").equals("acFoo")); Assert.assertTrue(modifiedReq.headers().get("entityId").equals("enBar")); Assert.assertTrue(modifiedReq.headers().get("entityId").equals("enBar")); Assert.assertTrue(modifiedReq.headers().get("checkId").equals("chFoo")); Assert.assertTrue(modifiedReq.headers().get("metricId").equals("myMetric")); testRouteHandlerCalled = false; modifiedReq = testPattern("/software/:name/:version", "/software/blueflood/v0.1"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(2, modifiedReq.headers().names().size()); Assert.assertTrue(modifiedReq.headers().get("name").equals("blueflood")); Assert.assertTrue(modifiedReq.headers().get("version").equals("v0.1")); testRouteHandlerCalled = false; modifiedReq = testPattern("/software/:name/:version/", "/software/blueflood/v0.1/"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(2, modifiedReq.headers().names().size()); Assert.assertTrue(modifiedReq.headers().get("name").equals("blueflood")); Assert.assertTrue(modifiedReq.headers().get("version").equals("v0.1")); testRouteHandlerCalled = false; modifiedReq = testPattern("/:name/:version","/blueflood/v0.1"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(2, modifiedReq.headers().names().size()); Assert.assertTrue(modifiedReq.headers().get("name").equals("blueflood")); Assert.assertTrue(modifiedReq.headers().get("version").equals("v0.1")); testRouteHandlerCalled = false; } | public void get(String pattern, HttpRequestHandler handler) { addBinding(pattern, HttpMethod.GET.name(), handler, getBindings); } | RouteMatcher { public void get(String pattern, HttpRequestHandler handler) { addBinding(pattern, HttpMethod.GET.name(), handler, getBindings); } } | RouteMatcher { public void get(String pattern, HttpRequestHandler handler) { addBinding(pattern, HttpMethod.GET.name(), handler, getBindings); } RouteMatcher(); } | RouteMatcher { public void get(String pattern, HttpRequestHandler handler) { addBinding(pattern, HttpMethod.GET.name(), handler, getBindings); } RouteMatcher(); RouteMatcher withNoRouteHandler(HttpRequestHandler noRouteHandler); void route(ChannelHandlerContext context, FullHttpRequest request); void get(String pattern, HttpRequestHandler handler); void put(String pattern, HttpRequestHandler handler); void post(String pattern, HttpRequestHandler handler); void delete(String pattern, HttpRequestHandler handler); void head(String pattern, HttpRequestHandler handler); void options(String pattern, HttpRequestHandler handler); void connect(String pattern, HttpRequestHandler handler); void patch(String pattern, HttpRequestHandler handler); Set<String> getSupportedMethodsForURL(String URL); } | RouteMatcher { public void get(String pattern, HttpRequestHandler handler) { addBinding(pattern, HttpMethod.GET.name(), handler, getBindings); } RouteMatcher(); RouteMatcher withNoRouteHandler(HttpRequestHandler noRouteHandler); void route(ChannelHandlerContext context, FullHttpRequest request); void get(String pattern, HttpRequestHandler handler); void put(String pattern, HttpRequestHandler handler); void post(String pattern, HttpRequestHandler handler); void delete(String pattern, HttpRequestHandler handler); void head(String pattern, HttpRequestHandler handler); void options(String pattern, HttpRequestHandler handler); void connect(String pattern, HttpRequestHandler handler); void patch(String pattern, HttpRequestHandler handler); Set<String> getSupportedMethodsForURL(String URL); } |
@Test public void getOldestWithSingleStampReturnsSame() { HashMap<Integer, UpdateStamp> stamps = new HashMap<Integer, UpdateStamp>(); long time = 1234L; UpdateStamp stamp = new UpdateStamp(time, UpdateStamp.State.Active, false); stamps.put(0, stamp); when(context.getSlotStamps(Matchers.<Granularity>any(), anyInt())) .thenReturn(stamps) .thenReturn(null); SlotState slotState = new SlotState(Granularity.MIN_5, 0, stamp.getState()) .withTimestamp(time); String expected = slotState.toString(); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(1, result.size()); assertTrue(result.contains(expected)); } | public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } |
@Test public void testEmptyRequest() throws IOException { String requestBody = ""; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid request body", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testEmptyJsonRequest() throws IOException { String requestBody = "{}"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 3, errorResponse.getErrors().size()); assertEquals("Invalid tenant", "", errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testEmptyTenantId() throws IOException { BluefloodGauge gauge = new BluefloodGauge("gauge.a.b", 5); FullHttpRequest request = createIngestRequest(createRequestBody("", new DefaultClockImpl().now().getMillis(), 0 , new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "tenantId", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", "", errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testInvalidFlushInterval() throws IOException { BluefloodGauge gauge = new BluefloodGauge("gauge.a.b", 5); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), -1 , new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "must be between 0 and 9223372036854775807", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "flushInterval", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testCollectionTimeInPast() throws IOException { BluefloodGauge gauge = new BluefloodGauge("gauge.a.b", 5); long collectionTimeInPast = new DefaultClockImpl().now().getMillis() - 1000 - Configuration.getInstance().getLongProperty( CoreConfig.BEFORE_CURRENT_COLLECTIONTIME_MS ); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, collectionTimeInPast, 0 , new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past. " + "Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "timestamp", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testCollectionTimeInFuture() throws IOException { BluefloodGauge gauge = new BluefloodGauge("gauge.a.b", 5); long collectionTimeInFuture = new DefaultClockImpl().now().getMillis() + 1000 + Configuration.getInstance().getLongProperty( CoreConfig.AFTER_CURRENT_COLLECTIONTIME_MS ); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, collectionTimeInFuture, 0 , new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past. " + "Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "timestamp", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testAggregatedMetricsNotSet() throws IOException { FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0 , null, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "At least one of the aggregated metrics(gauges, counters, timers, sets) " + "are expected", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testGaugeEmptyMetricName() throws IOException { BluefloodGauge gauge = new BluefloodGauge("", 5); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "gauges[0].name", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testGaugeEmptyMetricValue() throws IOException { String metricName = "gauge.a.b"; BluefloodGauge gauge = new BluefloodGauge(metricName, null); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be null", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "gauges[0].value", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testCounterEmptyMetricName() throws IOException { BluefloodCounter counter = new BluefloodCounter("", 5, 0.1); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, new BluefloodCounter[]{counter}, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "counters[0].name", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void getOldestWithTimeInFutureReturnsEmpty() { HashMap<Integer, UpdateStamp> stamps = new HashMap<Integer, UpdateStamp>(); long time = System.currentTimeMillis() + 1234L; UpdateStamp stamp = new UpdateStamp(time, UpdateStamp.State.Active, false); stamps.put(0, stamp); when(context.getSlotStamps(Matchers.<Granularity>any(), anyInt())) .thenReturn(stamps) .thenReturn(null); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(0, result.size()); } | public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } |
@Test public void testCounterEmptyMetricValue() throws IOException { String metricName = "counter.a.b"; BluefloodCounter counter = new BluefloodCounter(metricName, null, 0.1); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, new BluefloodCounter[]{counter}, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be null", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "counters[0].value", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testCounterEmptyMetricRate() throws IOException { String metricName = "counter.a.b"; BluefloodCounter counter = new BluefloodCounter(metricName, 5, null); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, new BluefloodCounter[]{counter}, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be null", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "counters[0].rate", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testTimerEmptyMetricName() throws IOException { BluefloodTimer timer = new BluefloodTimer("", 5); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, null, new BluefloodTimer[]{timer}, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "timers[0].name", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testTimerEmptyMetricCount() throws IOException { String metricName = "timer.a.b"; BluefloodTimer timer = new BluefloodTimer(metricName, null); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, null, new BluefloodTimer[]{timer}, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be null", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "timers[0].count", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testSetEmptyMetricName() throws IOException { BluefloodSet sets = new BluefloodSet("", new String[]{}); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, null, null, new BluefloodSet[]{sets})); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "sets[0].name", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testValidGauge() throws IOException { BluefloodGauge gauge = new BluefloodGauge("gauge.a.b", 5); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String responseBody = argument.getValue().content().toString(Charset.defaultCharset()); assertEquals("Invalid response", "", responseBody); assertEquals("Invalid status", HttpResponseStatus.OK, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testValidCounter() throws IOException { BluefloodCounter counter = new BluefloodCounter("counter.a.b", 5, 0.1); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, new BluefloodCounter[]{counter}, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String responseBody = argument.getValue().content().toString(Charset.defaultCharset()); assertEquals("Invalid response", "", responseBody); assertEquals("Invalid status", HttpResponseStatus.OK, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testValidTimer() throws IOException { BluefloodTimer timer = new BluefloodTimer("timer.a.b", 5); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, null, new BluefloodTimer[]{timer}, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String responseBody = argument.getValue().content().toString(Charset.defaultCharset()); assertEquals("Invalid response", "", responseBody); assertEquals("Invalid status", HttpResponseStatus.OK, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testValidSet() throws IOException { BluefloodSet set = new BluefloodSet("set.a.b", new String[]{"", ""});; FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, null, null, new BluefloodSet[]{set})); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String responseBody = argument.getValue().content().toString(Charset.defaultCharset()); assertEquals("Invalid response", "", responseBody); assertEquals("Invalid status", HttpResponseStatus.OK, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testEmptyButValidMultiJSON() { String badJson = "[]"; List<AggregatedPayload> bundle = HttpAggregatedMultiIngestionHandler.createBundleList(badJson); } | public static List<AggregatedPayload> createBundleList(String json) { Gson gson = new Gson(); JsonParser parser = new JsonParser(); JsonElement element = parser.parse(json); if (!element.isJsonArray()) { throw new InvalidDataException("Invalid request body"); } JsonArray jArray = element.getAsJsonArray(); ArrayList<AggregatedPayload> bundleList = new ArrayList<AggregatedPayload>(); for(JsonElement obj : jArray ) { AggregatedPayload bundle = AggregatedPayload.create(obj); bundleList.add(bundle); } return bundleList; } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { public static List<AggregatedPayload> createBundleList(String json) { Gson gson = new Gson(); JsonParser parser = new JsonParser(); JsonElement element = parser.parse(json); if (!element.isJsonArray()) { throw new InvalidDataException("Invalid request body"); } JsonArray jArray = element.getAsJsonArray(); ArrayList<AggregatedPayload> bundleList = new ArrayList<AggregatedPayload>(); for(JsonElement obj : jArray ) { AggregatedPayload bundle = AggregatedPayload.create(obj); bundleList.add(bundle); } return bundleList; } } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { public static List<AggregatedPayload> createBundleList(String json) { Gson gson = new Gson(); JsonParser parser = new JsonParser(); JsonElement element = parser.parse(json); if (!element.isJsonArray()) { throw new InvalidDataException("Invalid request body"); } JsonArray jArray = element.getAsJsonArray(); ArrayList<AggregatedPayload> bundleList = new ArrayList<AggregatedPayload>(); for(JsonElement obj : jArray ) { AggregatedPayload bundle = AggregatedPayload.create(obj); bundleList.add(bundle); } return bundleList; } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { public static List<AggregatedPayload> createBundleList(String json) { Gson gson = new Gson(); JsonParser parser = new JsonParser(); JsonElement element = parser.parse(json); if (!element.isJsonArray()) { throw new InvalidDataException("Invalid request body"); } JsonArray jArray = element.getAsJsonArray(); ArrayList<AggregatedPayload> bundleList = new ArrayList<AggregatedPayload>(); for(JsonElement obj : jArray ) { AggregatedPayload bundle = AggregatedPayload.create(obj); bundleList.add(bundle); } return bundleList; } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static List<AggregatedPayload> createBundleList(String json); } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { public static List<AggregatedPayload> createBundleList(String json) { Gson gson = new Gson(); JsonParser parser = new JsonParser(); JsonElement element = parser.parse(json); if (!element.isJsonArray()) { throw new InvalidDataException("Invalid request body"); } JsonArray jArray = element.getAsJsonArray(); ArrayList<AggregatedPayload> bundleList = new ArrayList<AggregatedPayload>(); for(JsonElement obj : jArray ) { AggregatedPayload bundle = AggregatedPayload.create(obj); bundleList.add(bundle); } return bundleList; } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static List<AggregatedPayload> createBundleList(String json); } |
@Test public void getOldestWithTwoStampsTimeInFutureReturnsOlderOfTheTwo() { HashMap<Integer, UpdateStamp> stamps = new HashMap<Integer, UpdateStamp>(); long time1 = 1234L; UpdateStamp stamp1 = new UpdateStamp(time1, UpdateStamp.State.Active, false); stamps.put(0, stamp1); long time2 = 1233L; UpdateStamp stamp2 = new UpdateStamp(time2, UpdateStamp.State.Active, false); stamps.put(1, stamp2); when(context.getSlotStamps(Matchers.<Granularity>any(), anyInt())) .thenReturn(stamps) .thenReturn(null); SlotState slotState = new SlotState(Granularity.MIN_5, 1, stamp2.getState()) .withTimestamp(time2); String expected = slotState.toString(); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(1, result.size()); assertTrue(result.contains(expected)); } | public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } |
@Test public void testEmptyRequest() throws IOException { String requestBody = ""; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid request body", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static List<AggregatedPayload> createBundleList(String json); } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static List<AggregatedPayload> createBundleList(String json); } |
@Test public void testNonArrayJsonRequest() throws IOException { String requestBody = "{}"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid request body", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static List<AggregatedPayload> createBundleList(String json); } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static List<AggregatedPayload> createBundleList(String json); } |
@Test public void testEmptyArrayJsonRequest() throws IOException { String requestBody = "[]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String responseBody = argument.getValue().content().toString(Charset.defaultCharset()); assertEquals("Invalid response", "No valid metrics", responseBody); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static List<AggregatedPayload> createBundleList(String json); } | HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static List<AggregatedPayload> createBundleList(String json); } |
@Test public void testElasticSearchInsertCalledWhenPut() throws Exception { Map<String, Object> event = createRandomEvent(); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO).insert(TENANT, event); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testInvalidRequestBody() throws Exception { ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createRequest(HttpMethod.POST, "", "{\"xxx\": \"yyy\"}")); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testMalformedEventPut() throws Exception { final String malformedJSON = "{\"when\":, what]}"; handler.handle(context, createRequest(HttpMethod.POST, "", malformedJSON)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testEmptyPut() throws Exception { Map<String, Object> event = new HashMap<String, Object>(); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); System.out.println(errorResponse); assertEquals("Number of errors invalid", 2, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testEmptyWhatField() throws Exception { Map<String, Object> event = new HashMap<String, Object>(); event.put(Event.FieldLabels.what.name(), ""); event.put(Event.FieldLabels.when.name(), System.currentTimeMillis()); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testWhenFieldInThePast() throws Exception { long collectionTimeInPast = new DefaultClockImpl().now().getMillis() - 10000 - Configuration.getInstance().getLongProperty( CoreConfig.BEFORE_CURRENT_COLLECTIONTIME_MS ); Map<String, Object> event = new HashMap<String, Object>(); event.put(Event.FieldLabels.what.name(), "xxxx"); event.put(Event.FieldLabels.when.name(), collectionTimeInPast); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past." + " Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testWhenFieldInTheFuture() throws Exception { long collectionTimeInFuture = new DefaultClockImpl().now().getMillis() + 10000 + Configuration.getInstance().getLongProperty( CoreConfig.AFTER_CURRENT_COLLECTIONTIME_MS ); Map<String, Object> event = new HashMap<String, Object>(); event.put(Event.FieldLabels.what.name(), "xxxx"); event.put(Event.FieldLabels.when.name(), collectionTimeInFuture); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past." + " Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void getOldestSkipsRolledStamps() { HashMap<Integer, UpdateStamp> stamps = new HashMap<Integer, UpdateStamp>(); long time1 = 1234L; UpdateStamp stamp1 = new UpdateStamp(time1, UpdateStamp.State.Active, false); stamps.put(0, stamp1); long time2 = 1233L; UpdateStamp stamp2 = new UpdateStamp(time2, UpdateStamp.State.Rolled, false); stamps.put(1, stamp2); when(context.getSlotStamps(Matchers.<Granularity>any(), anyInt())) .thenReturn(stamps) .thenReturn(null); SlotState slotState = new SlotState(Granularity.MIN_5, 0, stamp1.getState()) .withTimestamp(time1); String expected = slotState.toString(); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(1, result.size()); assertTrue(result.contains(expected)); } | public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } |
@Test public void testMinimumEventPut() throws Exception { Map<String, Object> event = new HashMap<String, Object>(); event.put(Event.FieldLabels.data.name(), "data"); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 2, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void emptyRequest_shouldGenerateErrorResponse() throws IOException { String requestBody = ""; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Cannot parse content", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void testEmptyJsonRequest() throws IOException { String requestBody = "{}"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Cannot parse content", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void testInvalidJsonRequest() throws IOException { String requestBody = "{\"xxxx\": yyyy}"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Cannot parse content", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void testEmptyJsonArrayRequest() throws IOException { String requestBody = "[]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "No valid metrics", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void testEmptyMetricRequest() throws IOException { String requestBody = "[{}]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 3, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void testSingleMetricInvalidMetricName() throws IOException { String metricName = ""; String singleMetric = createRequestBody(metricName, new DefaultClockImpl().now().getMillis(), 24 * 60 * 60, 1); String requestBody = "[" + singleMetric + "]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertEquals("Invalid error source", "metricName", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void testSingleMetricCollectionTimeInPast() throws IOException { long collectionTimeInPast = new DefaultClockImpl().now().getMillis() - 1000 - Configuration.getInstance().getLongProperty( CoreConfig.BEFORE_CURRENT_COLLECTIONTIME_MS ); String metricName = "a.b.c"; String singleMetric = createRequestBody(metricName, collectionTimeInPast, 24 * 60 * 60, 1); String requestBody = "[" + singleMetric + "]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertEquals("Invalid error source", "collectionTime", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past." + " Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void testSingleMetricCollectionTimeInFuture() throws IOException { long collectionTimeInFuture = new DefaultClockImpl().now().getMillis() + 1000 + Configuration.getInstance().getLongProperty( CoreConfig.AFTER_CURRENT_COLLECTIONTIME_MS ); String metricName = "a.b.c"; String singleMetric = createRequestBody(metricName, collectionTimeInFuture, 24 * 60 * 60, 1); String requestBody = "[" + singleMetric + "]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertEquals("Invalid error source", "collectionTime", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past." + " Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void testSingleMetricInvalidTTL() throws IOException { String metricName = "a.b.c"; String singleMetric = createRequestBody(metricName, new DefaultClockImpl().now().getMillis(), 0, 1); String requestBody = "[" + singleMetric + "]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertEquals("Invalid error source", "ttlInSeconds", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "must be between 1 and 2147483647", errorResponse.getErrors().get(0).getMessage()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void enqueueIncrementsWriterCounter() { SingleRollupWriteContext srwc = mock(SingleRollupWriteContext.class); rbw.enqueueRollupForWrite(srwc); verify(ctx).incrementWriteCounter(); verifyNoMoreInteractions(ctx); verifyZeroInteractions(srwc); } | public void enqueueRollupForWrite(SingleRollupWriteContext rollupWriteContext) { rollupQueue.add(rollupWriteContext); context.incrementWriteCounter(); if (rollupQueue.size() >= ROLLUP_BATCH_MIN_SIZE) { if (executor.getActiveCount() < executor.getPoolSize() || rollupQueue.size() >= ROLLUP_BATCH_MAX_SIZE) { drainBatch(); } } } | RollupBatchWriter { public void enqueueRollupForWrite(SingleRollupWriteContext rollupWriteContext) { rollupQueue.add(rollupWriteContext); context.incrementWriteCounter(); if (rollupQueue.size() >= ROLLUP_BATCH_MIN_SIZE) { if (executor.getActiveCount() < executor.getPoolSize() || rollupQueue.size() >= ROLLUP_BATCH_MAX_SIZE) { drainBatch(); } } } } | RollupBatchWriter { public void enqueueRollupForWrite(SingleRollupWriteContext rollupWriteContext) { rollupQueue.add(rollupWriteContext); context.incrementWriteCounter(); if (rollupQueue.size() >= ROLLUP_BATCH_MIN_SIZE) { if (executor.getActiveCount() < executor.getPoolSize() || rollupQueue.size() >= ROLLUP_BATCH_MAX_SIZE) { drainBatch(); } } } RollupBatchWriter(ThreadPoolExecutor executor, RollupExecutionContext context); } | RollupBatchWriter { public void enqueueRollupForWrite(SingleRollupWriteContext rollupWriteContext) { rollupQueue.add(rollupWriteContext); context.incrementWriteCounter(); if (rollupQueue.size() >= ROLLUP_BATCH_MIN_SIZE) { if (executor.getActiveCount() < executor.getPoolSize() || rollupQueue.size() >= ROLLUP_BATCH_MAX_SIZE) { drainBatch(); } } } RollupBatchWriter(ThreadPoolExecutor executor, RollupExecutionContext context); void enqueueRollupForWrite(SingleRollupWriteContext rollupWriteContext); synchronized void drainBatch(); } | RollupBatchWriter { public void enqueueRollupForWrite(SingleRollupWriteContext rollupWriteContext) { rollupQueue.add(rollupWriteContext); context.incrementWriteCounter(); if (rollupQueue.size() >= ROLLUP_BATCH_MIN_SIZE) { if (executor.getActiveCount() < executor.getPoolSize() || rollupQueue.size() >= ROLLUP_BATCH_MAX_SIZE) { drainBatch(); } } } RollupBatchWriter(ThreadPoolExecutor executor, RollupExecutionContext context); void enqueueRollupForWrite(SingleRollupWriteContext rollupWriteContext); synchronized void drainBatch(); } |
@Test public void testGranularityFromStateCol() { Granularity myGranularity = serDes.granularityFromStateCol("metrics_full,1,okay"); Assert.assertNotNull(myGranularity); Assert.assertEquals(myGranularity, Granularity.FULL); myGranularity = serDes.granularityFromStateCol("FULL"); Assert.assertNull(myGranularity); } | protected static Granularity granularityFromStateCol(String s) { String field = s.split(",", -1)[0]; for (Granularity g : Granularity.granularities()) if (g.name().startsWith(field)) return g; return null; } | SlotStateSerDes { protected static Granularity granularityFromStateCol(String s) { String field = s.split(",", -1)[0]; for (Granularity g : Granularity.granularities()) if (g.name().startsWith(field)) return g; return null; } } | SlotStateSerDes { protected static Granularity granularityFromStateCol(String s) { String field = s.split(",", -1)[0]; for (Granularity g : Granularity.granularities()) if (g.name().startsWith(field)) return g; return null; } } | SlotStateSerDes { protected static Granularity granularityFromStateCol(String s) { String field = s.split(",", -1)[0]; for (Granularity g : Granularity.granularities()) if (g.name().startsWith(field)) return g; return null; } static SlotState deserialize(String stateStr); String serialize(SlotState state); String serialize(Granularity gran, int slot, UpdateStamp.State state); } | SlotStateSerDes { protected static Granularity granularityFromStateCol(String s) { String field = s.split(",", -1)[0]; for (Granularity g : Granularity.granularities()) if (g.name().startsWith(field)) return g; return null; } static SlotState deserialize(String stateStr); String serialize(SlotState state); String serialize(Granularity gran, int slot, UpdateStamp.State state); } |
@Test public void testSingleMetricInvalidMetricValue() throws IOException { String metricName = "a.b.c"; String singleMetric = createRequestBody(metricName, new DefaultClockImpl().now().getMillis(), 24 * 60 * 60, null); String requestBody = "[" + singleMetric + "]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); System.out.println(errorResponse); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertNull("Invalid error source", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "No valid metrics", errorResponse.getErrors().get(0).getMessage()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void testMultiMetricsInvalidRequest() throws IOException { String metricName1 = "a.b.c.1"; String metricName2 = "a.b.c.2"; FullHttpRequest request = createIngestRequest(generateInvalidMetrics(metricName1, metricName2)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 2, errorResponse.getErrors().size()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid tenant", metricName1, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid error source", "ttlInSeconds", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "must be between 1 and 2147483647", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(1).getTenantId()); assertEquals("Invalid tenant", metricName2, errorResponse.getErrors().get(1).getMetricName()); assertEquals("Invalid error source", "collectionTime", errorResponse.getErrors().get(1).getSource()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past." + " Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(1).getMessage()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } |
@Test public void testWithNoQueryParams() throws IOException { FullHttpRequest request = createQueryRequest(""); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "No query parameters present.", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } HttpRollupsQueryHandler(); @VisibleForTesting HttpRollupsQueryHandler(BasicRollupsOutputSerializer<JSONObject> serializer); } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } HttpRollupsQueryHandler(); @VisibleForTesting HttpRollupsQueryHandler(BasicRollupsOutputSerializer<JSONObject> serializer); @Override MetricData GetDataByPoints(String tenantId,
String metric,
long from,
long to,
int points); @Override MetricData GetDataByResolution(String tenantId,
String metric,
long from,
long to,
Resolution resolution); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } HttpRollupsQueryHandler(); @VisibleForTesting HttpRollupsQueryHandler(BasicRollupsOutputSerializer<JSONObject> serializer); @Override MetricData GetDataByPoints(String tenantId,
String metric,
long from,
long to,
int points); @Override MetricData GetDataByResolution(String tenantId,
String metric,
long from,
long to,
Resolution resolution); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testMissingRequiredQueryParams() throws IOException { FullHttpRequest request = createQueryRequest("?from=111111"); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Either 'points' or 'resolution' is required.", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } HttpRollupsQueryHandler(); @VisibleForTesting HttpRollupsQueryHandler(BasicRollupsOutputSerializer<JSONObject> serializer); } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } HttpRollupsQueryHandler(); @VisibleForTesting HttpRollupsQueryHandler(BasicRollupsOutputSerializer<JSONObject> serializer); @Override MetricData GetDataByPoints(String tenantId,
String metric,
long from,
long to,
int points); @Override MetricData GetDataByResolution(String tenantId,
String metric,
long from,
long to,
Resolution resolution); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } HttpRollupsQueryHandler(); @VisibleForTesting HttpRollupsQueryHandler(BasicRollupsOutputSerializer<JSONObject> serializer); @Override MetricData GetDataByPoints(String tenantId,
String metric,
long from,
long to,
int points); @Override MetricData GetDataByResolution(String tenantId,
String metric,
long from,
long to,
Resolution resolution); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testRequestWithSerializationException() throws IOException { FullHttpRequest request = createQueryRequest("?points=10&from=1&to=2"); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); String message = "mock exception message"; when(serializer.transformRollupData(any(MetricData.class), anySet())).thenThrow(new SerializationException(message)); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", message, errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.INTERNAL_SERVER_ERROR, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } HttpRollupsQueryHandler(); @VisibleForTesting HttpRollupsQueryHandler(BasicRollupsOutputSerializer<JSONObject> serializer); } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } HttpRollupsQueryHandler(); @VisibleForTesting HttpRollupsQueryHandler(BasicRollupsOutputSerializer<JSONObject> serializer); @Override MetricData GetDataByPoints(String tenantId,
String metric,
long from,
long to,
int points); @Override MetricData GetDataByResolution(String tenantId,
String metric,
long from,
long to,
Resolution resolution); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } HttpRollupsQueryHandler(); @VisibleForTesting HttpRollupsQueryHandler(BasicRollupsOutputSerializer<JSONObject> serializer); @Override MetricData GetDataByPoints(String tenantId,
String metric,
long from,
long to,
int points); @Override MetricData GetDataByResolution(String tenantId,
String metric,
long from,
long to,
Resolution resolution); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testWithNoRequestBody() throws IOException { FullHttpRequest request = createQueryRequest("", ""); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid body. Expected JSON array of metrics.", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testWithTooMayLocatorsInRequestBody() throws IOException { int maxLimit = Configuration.getInstance().getIntegerProperty(HttpConfig.MAX_METRICS_PER_BATCH_QUERY); FullHttpRequest request = createQueryRequest("", createRequestBody(maxLimit + 1)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Too many metrics fetch in a single call. Max limit is " + maxLimit + ".", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testWithNoQueryParams() throws IOException { FullHttpRequest request = createQueryRequest("", createRequestBody(1)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "No query parameters present.", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
@Test public void testMissingRequiredQueryParams() throws IOException { FullHttpRequest request = createQueryRequest("?from=111111", createRequestBody(1)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Either 'points' or 'resolution' is required.", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } | @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } |
Subsets and Splits