/** * Flushes the data that the channel might have internally. */ @Override public void flush() { telemetryBuffer.flush(); }
/** * Sets the buffer size * * @param maxTelemetriesInBatch * should be between MIN_MAX_TELEMETRY_BUFFER_CAPACITY and * MAX_MAX_TELEMETRY_BUFFER_CAPACITY inclusive if the number is lower * than the minimum then the minimum will be used if the number is * higher than the maximum then the maximum will be used */ public void setMaxTelemetriesInBatch(int maxTelemetriesInBatch) { telemetryBuffer.setMaxTelemetriesInBatch(maxTelemetriesInBatch); }
/** * Sets the time tow wait before flushing the internal buffer * * @param transmitBufferTimeoutInSeconds * should be between MIN_FLUSH_BUFFER_TIMEOUT_IN_SECONDS and * MAX_FLUSH_BUFFER_TIMEOUT_IN_SECONDS inclusive if the number is * lower than the minimum then the minimum will be used if the number * is higher than the maximum then the maximum will be used */ public void setTransmitBufferTimeoutInSeconds(int transmitBufferTimeoutInSeconds) { telemetryBuffer.setTransmitBufferTimeoutInSeconds(transmitBufferTimeoutInSeconds); }
@Test public void testSetMaxTelemetriesInBatchWithBiggerSize() { MockSender mockSender = new MockSender() .setExpectedNumberOfScheduleSendCalls(0) .setExpectedNumberOfSendNowCalls(1) .setExpectedTelemetriesNumberInScheduleSend(0) .setExpectedTelemetriesNumberInSendNow(11); // Create a buffer with max buffer size of 10 and timeout of 10 seconds LimitsEnforcer maxEnforcer = createEnforcerWithCurrentValue(1, 10); LimitsEnforcer sendEnforcer = createEnforcerWithCurrentValue(30); TelemetryBuffer testedBuffer = new TelemetryBuffer(mockSender, maxEnforcer, sendEnforcer); for (int i = 0; i < 1; ++i) { testedBuffer.add("mockTelemetry"); } testedBuffer.setMaxTelemetriesInBatch(11); for (int i = 0; i < 10; ++i) { testedBuffer.add("mockTelemetry"); } mockSender.waitForFinish(1L); }
@Test public void testAddOneTelemetry() throws Exception { TelemetriesTransmitter mockSender = Mockito.mock(TelemetriesTransmitter.class); LimitsEnforcer maxEnforcer = createEnforcerWithCurrentValue(128); LimitsEnforcer sendEnforcer = createEnforcerWithCurrentValue(2); TelemetryBuffer testedBuffer = new TelemetryBuffer(mockSender, maxEnforcer, sendEnforcer); testedBuffer.add("mockTelemetry"); Mockito.verify(mockSender, Mockito.times(1)).scheduleSend((TelemetriesTransmitter.TelemetriesFetcher) any(), anyLong(), (TimeUnit) anyObject()); }
private void testFlushWithData(int expectedTelemetriesNumberInSendNow) { MockSender mockSender = new MockSender() .setExpectedNumberOfScheduleSendCalls(1) .setExpectedNumberOfSendNowCalls(1) .setExpectedTelemetriesNumberInScheduleSend(0) .setExpectedTelemetriesNumberInSendNow(expectedTelemetriesNumberInSendNow); // Create a buffer with max buffer size of 10 and timeout of 10 seconds LimitsEnforcer maxEnforcer = createEnforcerWithCurrentValue(1, 10); LimitsEnforcer sendEnforcer = createEnforcerWithCurrentValue(1, 3); TelemetryBuffer testedBuffer = new TelemetryBuffer(mockSender, maxEnforcer, sendEnforcer); for (int i = 0; i < expectedTelemetriesNumberInSendNow; ++i) { testedBuffer.add("mockTelemetry"); } testedBuffer.flush(); mockSender.waitForFinish(6L); }
@Test public void testSetTransmitBufferTimeoutInSecondsShorterTime() { MockSender mockSender = new MockSender() .setExpectedNumberOfScheduleSendCalls(0) .setExpectedNumberOfSendNowCalls(1) .setExpectedTelemetriesNumberInScheduleSend(0) .setExpectedTelemetriesNumberInSendNow(2); // Create a buffer with max buffer size of 10 and timeout of 10 seconds LimitsEnforcer maxEnforcer = createEnforcerWithCurrentValue(10); LimitsEnforcer sendEnforcer = createEnforcerWithCurrentValue(1, 30); TelemetryBuffer testedBuffer = new TelemetryBuffer(mockSender, maxEnforcer, sendEnforcer); for (int i = 0; i < 2; ++i) { testedBuffer.add("mockTelemetry"); } testedBuffer.setTransmitBufferTimeoutInSeconds(1); mockSender.waitForFinish(1L); }
protected synchronized void initialize(String endpointAddress, String maxTransmissionStorageCapacity, boolean developerMode, LimitsEnforcer maxTelemetryBufferCapacityEnforcer, LimitsEnforcer sendIntervalInSeconds, boolean throttling, int maxInstantRetry) { if (isInitailized) { return; } makeSureEndpointAddressIsValid(endpointAddress); telemetriesTransmitter = getTransmitterFactory().create(endpointAddress, maxTransmissionStorageCapacity, throttling, maxInstantRetry); telemetryBuffer = new TelemetryBuffer<>(telemetriesTransmitter, maxTelemetryBufferCapacityEnforcer, sendIntervalInSeconds); setDeveloperMode(developerMode); isInitailized = true; }
@Test public void testFlushWithZero() throws Exception { TelemetriesTransmitter mockSender = Mockito.mock(TelemetriesTransmitter.class); // Create a buffer with max buffer size of 10 and timeout of 10 seconds LimitsEnforcer maxEnforcer = createEnforcerWithCurrentValue(10); LimitsEnforcer sendEnforcer = createEnforcerWithCurrentValue(3); TelemetryBuffer testedBuffer = new TelemetryBuffer(mockSender, maxEnforcer, sendEnforcer); testedBuffer.flush(); Mockito.verify(mockSender, Mockito.never()).sendNow(anyCollectionOf(String.class)); }
@Override protected boolean doSend(Telemetry telemetry) { StringWriter writer = new StringWriter(); JsonTelemetryDataSerializer jsonWriter = null; try { jsonWriter = new JsonTelemetryDataSerializer(writer); telemetry.serialize(jsonWriter); jsonWriter.close(); String asJson = writer.toString(); telemetryBuffer.add(asJson); telemetry.reset(); } catch (IOException e) { InternalLogger.INSTANCE.error("Failed to serialize Telemetry"); InternalLogger.INSTANCE.trace("Stack trace is %s", ExceptionUtils.getStackTrace(e)); return false; } return true; }
@Test public void testConstructor() { LocalForwarderTelemetryChannel ch = new LocalForwarderTelemetryChannel( "localhost", false, 555, 6); assertFalse("isDeveloperMode should be false", ch.isDeveloperMode()); assertEquals(555, ch.getTelemetryBuffer().getMaxTelemetriesInBatch()); assertEquals(6, ch.getTelemetryBuffer().getTransmitBufferTimeoutInSeconds()); }
/** * The method will flush the telemetries currently in the buffer to the {@link com.microsoft.applicationinsights.internal.channel.TelemetriesTransmitter} */ public void flush() { synchronized (lock) { if (telemetries.size() != 0) { if (!sender.sendNow(prepareTelemetriesForSend())) { InternalLogger.INSTANCE.error("Failed to flush buffer data to network"); } } } }
@Test public void testSetMaxTelemetriesInBatchWithSmallerSizeButLargerThanWhatInBuffer() { MockSender mockSender = new MockSender() .setExpectedNumberOfScheduleSendCalls(0) .setExpectedNumberOfSendNowCalls(1) .setExpectedTelemetriesNumberInScheduleSend(0) .setExpectedTelemetriesNumberInSendNow(3) .setExpectedNumberOfScheduleSendRequests(2); // Create a buffer with max buffer size of 10 and timeout of 10 seconds LimitsEnforcer maxEnforcer = createEnforcerWithCurrentValue(1, 10); LimitsEnforcer sendEnforcer = createEnforcerWithCurrentValue(30); TelemetryBuffer testedBuffer = new TelemetryBuffer(mockSender, maxEnforcer, sendEnforcer); for (int i = 0; i < 2; ++i) { testedBuffer.add("mockTelemetry"); } testedBuffer.setMaxTelemetriesInBatch(3); for (int i = 0; i < 2; ++i) { testedBuffer.add("mockTelemetry"); } mockSender.waitForFinish(1L); }
@Test public void testSendWhenBufferIsFullInDeveloperMode() throws Exception { TelemetriesTransmitter mockSender = Mockito.mock(TelemetriesTransmitter.class); LimitsEnforcer maxEnforcer = createEnforcerWithCurrentValue(1); LimitsEnforcer sendEnforcer = createDefaultSenderTimeoutEnforcer(); TelemetryBuffer testedBuffer = new TelemetryBuffer(mockSender, maxEnforcer, sendEnforcer); for (int i = 0; i < 2; ++i) { testedBuffer.add("mockTelemetry"); } Mockito.verify(mockSender, Mockito.never()).scheduleSend((TelemetriesTransmitter.TelemetriesFetcher)any(), anyLong(), (TimeUnit)anyObject()); Mockito.verify(mockSender, Mockito.times(2)).sendNow(anyCollectionOf(String.class)); }
@Test(expected = NullPointerException.class) public void testNullMaxTelemetriesEnforcer() throws Exception { TelemetriesTransmitter mockSender = Mockito.mock(TelemetriesTransmitter.class); LimitsEnforcer sendEnforcer = LimitsEnforcer.createWithClosestLimitOnError(MOCK_PROPERTY_NAME, 1, 200, 20, null); new TelemetryBuffer(mockSender, null, sendEnforcer); }
@Test public void sendAddsItemToBuffer() { final MetricTelemetry telemetry = new MetricTelemetry(); telemetry.getContext().setInstrumentationKey("fake-ikey"); channel.send(telemetry); verify(mockBuffer, times(1)).add(any(Telemetry.class)); }
@Test public void testMapConstructor() { Map<String, String> args = new HashMap<String, String>() {{ put(TelemetryChannelBase.DEVELOPER_MODE_NAME, "false"); put(TelemetryChannelBase.FLUSH_BUFFER_TIMEOUT_IN_SECONDS_NAME, "7"); put(TelemetryChannelBase.MAX_TELEMETRY_BUFFER_CAPACITY_NAME, "789"); put(TelemetryChannelBase.ENDPOINT_ADDRESS_NAME, "myhost.local"); }}; LocalForwarderTelemetryChannel ch = new LocalForwarderTelemetryChannel(args); assertFalse("isDeveloperMode shoudl be false", ch.isDeveloperMode()); assertEquals(789, ch.getTelemetryBuffer().getMaxTelemetriesInBatch()); assertEquals(7, ch.getTelemetryBuffer().getTransmitBufferTimeoutInSeconds()); }
if (!sender.sendNow(prepareTelemetriesForSend())) {
@Test public void testSetMaxTelemetriesInBatchWithSmallerSize() { MockSender mockSender = new MockSender() .setExpectedNumberOfScheduleSendCalls(0) .setExpectedNumberOfSendNowCalls(1) .setExpectedTelemetriesNumberInScheduleSend(0) .setExpectedTelemetriesNumberInSendNow(2); // Create a buffer with max buffer size of 10 and timeout of 10 seconds LimitsEnforcer maxEnforcer = createEnforcerWithCurrentValue(1, 10); LimitsEnforcer sendEnforcer = createEnforcerWithCurrentValue(30); TelemetryBuffer testedBuffer = new TelemetryBuffer(mockSender, maxEnforcer, sendEnforcer); for (int i = 0; i < 2; ++i) { testedBuffer.add("mockTelemetry"); } testedBuffer.setMaxTelemetriesInBatch(1); mockSender.waitForFinish(1L); }
@SuppressWarnings("unchecked") @Test public void testSendWhenBufferIsFullInNonDeveloperMode() throws Exception { TelemetriesTransmitter mockSender = Mockito.mock(TelemetriesTransmitter.class); Mockito.doReturn(true).when(mockSender).sendNow(anyCollection()); Mockito.doReturn(true).when(mockSender).scheduleSend(any(TelemetriesTransmitter.TelemetriesFetcher.class), anyLong(), any(TimeUnit.class)); LimitsEnforcer maxEnforcer = createEnforcerWithCurrentValue(2); LimitsEnforcer sendEnforcer = createDefaultSenderTimeoutEnforcer(); TelemetryBuffer testedBuffer = new TelemetryBuffer(mockSender, maxEnforcer, sendEnforcer); for (int i = 0; i < 2; ++i) { testedBuffer.add("mockTelemetry"); } Mockito.verify(mockSender, Mockito.times(1)).scheduleSend((TelemetriesTransmitter.TelemetriesFetcher) any(), anyLong(), (TimeUnit) anyObject()); Mockito.verify(mockSender, Mockito.times(1)).sendNow(anyCollectionOf(String.class)); }