public void WaitsUntilTelemetryBufferIsSafeToModify() { var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle()); buffer.Capacity = 1; Task anotherThread; lock (buffer) { anotherThread = Task.Run(() => buffer.Process(new StubTelemetry())); Assert.IsFalse(anotherThread.Wait(10)); } Assert.IsTrue(anotherThread.Wait(50)); }
public void StartsTimerThatFlushesBufferAfterMaxTransmissionDelay() { var telemetrySerialized = new ManualResetEventSlim(); var serializer = new StubTelemetrySerializer(); serializer.OnSerialize = telemetry => { telemetrySerialized.Set(); }; var buffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle()); buffer.MaxTransmissionDelay = TimeSpan.FromMilliseconds(1); buffer.Process(new StubTelemetry()); Assert.True(telemetrySerialized.Wait(50)); }
public void FlushesBufferToPreventLossOfTelemetry() { var applicationLifecycle = new StubApplicationLifecycle(); var telemetrySerialized = new ManualResetEventSlim(); var serializer = new StubTelemetrySerializer(); serializer.OnSerialize = telemetry => { telemetrySerialized.Set(); }; var buffer = new TelemetryBuffer(serializer, applicationLifecycle); buffer.Process(new StubTelemetry()); applicationLifecycle.OnStopping(ApplicationStoppingEventArgs.Empty); Assert.True(telemetrySerialized.Wait(50)); }
internal ServerTelemetryChannel(INetwork network, IApplicationLifecycle applicationLifecycle) { var policies = new TransmissionPolicy[] { new ApplicationLifecycleTransmissionPolicy(applicationLifecycle), new ErrorHandlingTransmissionPolicy(), new NetworkAvailabilityTransmissionPolicy(network), new ThrottlingTransmissionPolicy() }; this.Transmitter = new Transmitter(policies: policies); this.TelemetrySerializer = new TelemetrySerializer(this.Transmitter); this.TelemetryBuffer = new Implementation.TelemetryBuffer(this.TelemetrySerializer, applicationLifecycle); this.telemetryBufferCapacity = this.TelemetryBuffer.Capacity; this.TelemetryProcessor = this.TelemetryBuffer; }
public void PreventsOperatingSystemFromSuspendingAsynchronousOperations() { var applicationLifecycle = new StubApplicationLifecycle(); var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), applicationLifecycle); buffer.Process(new StubTelemetry()); bool deferralAcquired = false; Func <Func <Task>, Task> asyncTaskRunner = asyncMethod => { deferralAcquired = true; return(asyncMethod()); }; applicationLifecycle.OnStopping(new ApplicationStoppingEventArgs(asyncTaskRunner)); Assert.True(deferralAcquired); }
public void DoesNotCancelPreviousFlush() { var telemetrySerialized = new ManualResetEventSlim(); var serializer = new StubTelemetrySerializer(); serializer.OnSerialize = telemetry => { telemetrySerialized.Set(); }; var buffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle()); buffer.MaxTransmissionDelay = TimeSpan.FromMilliseconds(1); buffer.Process(new StubTelemetry()); buffer.MaxTransmissionDelay = TimeSpan.FromSeconds(42); buffer.Process(new StubTelemetry()); Assert.True(telemetrySerialized.Wait(TimeSpan.FromMilliseconds(100))); }
public void SerializesTelemetryIfBufferIsNotEmpty() { List <ITelemetry> serializedTelemetry = null; var serializer = new StubTelemetrySerializer(); serializer.OnSerialize = telemetry => { serializedTelemetry = new List <ITelemetry>(telemetry); }; var telemetryBuffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle()); var expectedTelemetry = new StubTelemetry(); telemetryBuffer.Process(expectedTelemetry); telemetryBuffer.FlushAsync().GetAwaiter().GetResult(); Assert.Same(expectedTelemetry, serializedTelemetry.Single()); }
public void DoesNotContinueOnCapturedSynchronizationContextToImprovePerformance() { var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle()); buffer.Process(new StubTelemetry()); bool postedBack = false; using (var context = new StubSynchronizationContext()) { context.OnPost = (callback, state) => { postedBack = true; callback(state); }; buffer.FlushAsync().GetAwaiter().GetResult(); Assert.False(postedBack); } }
public void ThrowsArgumentOutOfRangeExceptionWhenNewValueIsLessThanMinimum() { var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle()); AssertEx.Throws <ArgumentOutOfRangeException>(() => buffer.Capacity = 0); AssertEx.Throws <ArgumentOutOfRangeException>(() => buffer.BacklogSize = 0); AssertEx.Throws <ArgumentOutOfRangeException>(() => buffer.BacklogSize = 1000); // 1001 is minimum anything low would throw. bool exceptionThrown = false; try { buffer.BacklogSize = 1001; // 1001 is valid and should not throw. } catch (Exception) { exceptionThrown = true; } Assert.IsTrue(exceptionThrown == false, "No exception should be thrown when trying to set backlog size to 1001"); }
public void CancelsPreviouslyStartedAutomaticFlushToPreventPreventPrematureTransmission() { var serializer = new StubTelemetrySerializer(); var buffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle()); buffer.MaxTransmissionDelay = TimeSpan.FromMilliseconds(1); buffer.Process(new StubTelemetry()); buffer.MaxTransmissionDelay = TimeSpan.FromMilliseconds(100); buffer.FlushAsync().Wait(); var autoFlushed = new ManualResetEventSlim(); serializer.OnSerialize = telemetry => { autoFlushed.Set(); }; buffer.Process(new StubTelemetry()); Assert.False(autoFlushed.Wait(30)); }
public void SerializesBufferOnThreadPoolToFreeUpCustomersThread() { int serializerThreadId = -1; var serializerInvoked = new ManualResetEventSlim(); var serializer = new StubTelemetrySerializer(); serializer.OnSerialize = telemetry => { serializerThreadId = Thread.CurrentThread.ManagedThreadId; serializerInvoked.Set(); }; var telemetryBuffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle()); telemetryBuffer.Process(new StubTelemetry()); Task dontWait = telemetryBuffer.FlushAsync(); Assert.True(serializerInvoked.Wait(100)); Assert.NotEqual(serializerThreadId, Thread.CurrentThread.ManagedThreadId); }
internal ServerTelemetryChannel(INetwork network, IApplicationLifecycle applicationLifecycle) { var policies = new TransmissionPolicy[] { #if !NETSTANDARD // We don't have implementation for IApplicationLifecycle for .NET Core new ApplicationLifecycleTransmissionPolicy(applicationLifecycle), #endif new ThrottlingTransmissionPolicy(), new ErrorHandlingTransmissionPolicy(), new PartialSuccessTransmissionPolicy(), new NetworkAvailabilityTransmissionPolicy(network), }; this.Transmitter = new Transmitter(policies: policies); this.TelemetrySerializer = new TelemetrySerializer(this.Transmitter); this.TelemetryBuffer = new TelemetryBuffer(this.TelemetrySerializer, applicationLifecycle); this.telemetryBufferCapacity = this.TelemetryBuffer.Capacity; this.TelemetryProcessor = this.TelemetryBuffer; this.isInitialized = false; }
public void ThrowsArgumentOutOfRangeExceptionWhenNewValueIsLessThanOne() { var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle()); Assert.Throws <ArgumentOutOfRangeException>(() => buffer.Capacity = 0); }
public void DefaultValueIsAppropriateForProductionEnvironmentAndUnitTests() { var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle()); Assert.Equal(500, buffer.Capacity); }
public void DefaultValueIsAppropriateForProductionEnvironmentAndUnitTests() { var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle()); Assert.Equal(TimeSpan.FromSeconds(30), buffer.MaxTransmissionDelay); }
public void ThrowsArgumentNullExceptionWhenTelemetryIsNull() { var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle()); Assert.Throws <ArgumentNullException>(() => buffer.Process((ITelemetry)null)); }
public void ImplementsIEnumerableToAllowInspectingBufferContentsInTests() { TelemetryBuffer instance = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle()); Assert.True(instance is IEnumerable <ITelemetry>); }