public void CanBeChangedByChannelToTunePerformance()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
var expectedValue = TimeSpan.FromSeconds(42);
buffer.MaxTransmissionDelay = expectedValue;
Assert.Equal(expectedValue, buffer.MaxTransmissionDelay);
}
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 TelemetryBuffer(this.TelemetrySerializer, applicationLifecycle);
this.telemetryBufferCapacity = this.TelemetryBuffer.Capacity;
this.TelemetryProcessor = this.TelemetryBuffer;
this.isInitialized = false;
}
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 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));
}
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 Initialize()
{
this.TelemetryBuffer = new TelemetryBuffer();
this.TelemetryChannel = new InMemoryChannel(this.TelemetryBuffer, new InMemoryTransmitter(this.TelemetryBuffer));
this.TelemetryClient = new TelemetryClient(new Extensibility.TelemetryConfiguration(instrumentationKey: TestInstrumentationKey, channel: this.TelemetryChannel));
this.TelemetryClient.Context.Component.Version = TestComponentVersion;
this.TelemetryClient.Context.Device.Type = TestDeviceType;
this.TelemetryClient.Context.Device.Id = TestDeviceId;
this.TelemetryClient.Context.Device.OperatingSystem = TestDeviceOperatingSystem;
this.TelemetryClient.Context.Device.OemName = TestDeviceOemName;
this.TelemetryClient.Context.Device.Model = TestDeviceModel;
this.TelemetryClient.Context.Cloud.RoleName = TestCloudRoleName;
this.TelemetryClient.Context.Cloud.RoleInstance = TestCloudRoleInstance;
this.TelemetryClient.Context.Session.Id = TestSessionId;
this.TelemetryClient.Context.Session.IsFirst = TestSessionIsFirst;
this.TelemetryClient.Context.User.Id = TestUserId;
this.TelemetryClient.Context.User.AccountId = TestUserAccountId;
this.TelemetryClient.Context.User.UserAgent = TestUserUserAgent;
this.TelemetryClient.Context.User.AuthenticatedUserId = TestUserAuthenticatedUserId;
this.TelemetryClient.Context.Operation.Id = TestOperationId;
this.TelemetryClient.Context.Operation.ParentId = TestOperationParentId;
this.TelemetryClient.Context.Operation.CorrelationVector = TestOperationCorrelationVector;
this.TelemetryClient.Context.Operation.SyntheticSource = TestOperationSyntheticSource;
this.TelemetryClient.Context.Operation.Name = TestOperationName;
this.TelemetryClient.Context.Location.Ip = TestLocationIp;
this.TelemetryClient.Context.Internal.SdkVersion = TestInternalSdkVersion;
this.TelemetryClient.Context.Internal.AgentVersion = TestInternalAgentVersion;
this.TelemetryClient.Context.Internal.NodeName = TestInternalNodeName;
}
public void FromBuffer_lower_ushort()
{
Assert.Equal(Int16.MaxValue + 1,
TelemetryBuffer.FromBuffer(new byte[] { 0x2, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }));
}
public void FromBuffer_upper_int()
{
Assert.Equal(Int32.MaxValue,
TelemetryBuffer.FromBuffer(new byte[] { 0xfc, 0xff, 0xff, 0xff, 0x7f, 0x0, 0x0, 0x0, 0x0 }));
}
public void FromBuffer_lower_long()
{
Assert.Equal((long)UInt32.MaxValue + 1,
TelemetryBuffer.FromBuffer(new byte[] { 0xf8, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0 }));
}
public void FromBuffer_Invalid()
{
Assert.Equal(0,
TelemetryBuffer.FromBuffer(new byte[] { 22, 0xff, 0xff, 0xff, 0x7f, 0, 0, 0, 0 }));
}
public void DoesntSerializeTelemetryIfBufferIsEmpty()
{
bool telemetrySerialized = false;
var serializer = new StubTelemetrySerializer();
serializer.OnSerialize = telemetry =>
{
telemetrySerialized = true;
};
var telemetryBuffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle());
telemetryBuffer.FlushAsync().GetAwaiter().GetResult();
Assert.False(telemetrySerialized);
}
public void ToBuffer_lower_int()
{
var bytes = TelemetryBuffer.ToBuffer((long)UInt16.MaxValue + 1);
Assert.Equal(new byte[] { 0xfc, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0 }, bytes);
}
public void FromBuffer_lower_neg_int()
{
Assert.Equal(Int32.MinValue,
TelemetryBuffer.FromBuffer(new byte[] { 0xfc, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0 }));
}
public void CanBeSetByChannelToTunePerformance()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
buffer.Capacity = 42;
Assert.Equal(42, buffer.Capacity);
}
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 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));
}
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 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);
}
public void EmptiesBufferAfterSerialization()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
buffer.Capacity = 10;
buffer.Process(new StubTelemetry());
buffer.FlushAsync().GetAwaiter().GetResult();
Assert.Equal(0, buffer.Count());
}
public void FromBuffer_Zero()
{
Assert.Equal(0,
TelemetryBuffer.FromBuffer(new byte[] { 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }));
}
public void FromBuffer_lower_neg_short()
{
Assert.Equal(Int16.MinValue,
TelemetryBuffer.FromBuffer(new byte[] { 0xfe, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }));
}
public void DefaultValueIsAppropriateForProductionEnvironmentAndUnitTests()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
Assert.Equal(500, buffer.Capacity);
}
public void FromBuffer_upper_neg_long()
{
Assert.Equal((long)Int32.MinValue - 1,
TelemetryBuffer.FromBuffer(new byte[] { 0xf8, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff }));
}
public void ThrowsArgumentOutOfRangeExceptionWhenNewValueIsLessThanOne()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
Assert.Throws<ArgumentOutOfRangeException>(() => buffer.Capacity = 0);
}
public void ToBuffer_upper_short()
{
var bytes = TelemetryBuffer.ToBuffer(Int16.MaxValue);
Assert.Equal(new byte[] { 0xfe, 0xff, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }, bytes);
}
public void DefaultValueIsAppropriateForProductionEnvironmentAndUnitTests()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
Assert.Equal(TimeSpan.FromSeconds(30), buffer.MaxTransmissionDelay);
}
public void ToBuffer_lower_neg_long()
{
var bytes = TelemetryBuffer.ToBuffer(Int64.MinValue);
Assert.Equal(new byte[] { 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80 }, bytes);
}
public void AddsTelemetryToBufferUntilItReachesMax()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
buffer.Capacity = 42;
buffer.Process(new StubTelemetry());
Assert.Equal(1, buffer.Count());
}
public void FromBuffer_upper_long()
{
Assert.Equal(Int64.MaxValue,
TelemetryBuffer.FromBuffer(new byte[] { 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f }));
}
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 FromBuffer_lower_uint()
{
Assert.Equal((long)Int32.MaxValue + 1,
TelemetryBuffer.FromBuffer(new byte[] { 0x4, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0 }));
}
public void FlushesBufferWhenNumberOfTelemetryItemsReachesMax()
{
var bufferFlushed = new ManualResetEventSlim();
IEnumerable<ITelemetry> flushedTelemetry = null;
var serializer = new StubTelemetrySerializer
{
OnSerialize = telemetry =>
{
flushedTelemetry = telemetry.ToList();
bufferFlushed.Set();
},
};
var telemetryBuffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle());
var sentTelemetry = new List<ITelemetry> { new StubTelemetry(), new StubTelemetry() };
telemetryBuffer.Capacity = sentTelemetry.Count;
foreach (ITelemetry item in sentTelemetry)
{
telemetryBuffer.Process(item);
}
Assert.True(bufferFlushed.Wait(30));
Assert.Equal(sentTelemetry, flushedTelemetry);
}
public void FromBuffer_lower_int()
{
Assert.Equal(UInt16.MaxValue + 1,
TelemetryBuffer.FromBuffer(new byte[] { 0xfc, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0 }));
}
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 FromBuffer_upper_short()
{
Assert.Equal(Int16.MaxValue,
TelemetryBuffer.FromBuffer(new byte[] { 0xfe, 0xff, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }));
}
public void ThrowsArgumentNullExceptionWhenTelemetryIsNull()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
Assert.Throws<ArgumentNullException>(() => buffer.Process((ITelemetry)null));
}
public void FromBuffer_upper_neg_short()
{
Assert.Equal(-1,
TelemetryBuffer.FromBuffer(new byte[] { 0xfe, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }));
}
public void WaitsUntilTelemetryBufferIsSafeToModify()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
buffer.Capacity = 1;
Task anotherThread;
lock (buffer)
{
anotherThread = TaskEx.Run(() => buffer.Process(new StubTelemetry()));
Assert.False(anotherThread.Wait(10));
}
Assert.True(anotherThread.Wait(50));
}
public void FromBuffer_upper_neg_int()
{
Assert.Equal(Int16.MinValue - 1,
TelemetryBuffer.FromBuffer(new byte[] { 0xfc, 0xff, 0x7f, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0 }));
}
public void ImplementsIEnumerableToAllowInspectingBufferContentsInTests()
{
TelemetryBuffer instance = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
Assert.True(instance is IEnumerable<ITelemetry>);
}
public void ToBuffer_upper_uint()
{
var bytes = TelemetryBuffer.ToBuffer(UInt32.MaxValue);
Assert.Equal(new byte[] { 0x4, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0 }, bytes);
}
public void CanBeSetByChannelToTunePerformance()
{
var buffer = new TelemetryBuffer();
buffer.Capacity = 42;
Assert.Equal(42, buffer.Capacity);
}
public void FromBuffer_lower_neg_long()
{
Assert.Equal(Int64.MinValue,
TelemetryBuffer.FromBuffer(new byte[] { 0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80 }));
}
public void ToBuffer_Zero()
{
var bytes = TelemetryBuffer.ToBuffer(0);
Assert.Equal(new byte[] { 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }, bytes);
}
public void ToBuffer_lower_ushort()
{
var bytes = TelemetryBuffer.ToBuffer((long)Int16.MaxValue + 1);
Assert.Equal(new byte[] { 0x2, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }, bytes);
}
public void ToBuffer_lower_neg_short()
{
var bytes = TelemetryBuffer.ToBuffer(Int16.MinValue);
Assert.Equal(new byte[] { 0xfe, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }, bytes);
}
public void ToBuffer_upper_long()
{
var bytes = TelemetryBuffer.ToBuffer(Int64.MaxValue);
Assert.Equal(new byte[] { 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f }, bytes);
}
public void DefaultValueIsAppropriateForProductionEnvironmentAndUnitTests()
{
var buffer = new TelemetryBuffer();
Assert.Equal(500, buffer.Capacity);
}
public void ToBuffer_upper_neg_short()
{
var bytes = TelemetryBuffer.ToBuffer(-1);
Assert.Equal(new byte[] { 0xfe, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }, bytes);
}
public void ToBuffer_upper_neg_long()
{
var bytes = TelemetryBuffer.ToBuffer((long)Int32.MinValue - 1);
Assert.Equal(new byte[] { 0xf8, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff }, bytes);
}
internal TelimenaInMemoryTransmitter(TelemetryBuffer buffer, DeliverySettings deliverySettings) : base(buffer)
{
this.DeliverySettings = deliverySettings;
this.SendingInterval = deliverySettings.DeliveryInterval;
}
public TelimenaInMemoryChannel(TelemetryBuffer buffer, TelimenaInMemoryTransmitter transmitter) : base(buffer
, transmitter)
{
}
