public void OnEndGeneratesWebEventsOnErrorEvent()
{
using (var listener = new TestEventListener())
{
listener.EnableEvents(WebEventsPublisher.Log, EventLevel.LogAlways, (EventKeywords)AllKeywords);
this.module.Invoke("OnEndRequest", new[] { typeof(object), typeof(EventArgs) }, new object[] { HttpModuleHelper.GetFakeHttpApplication(), null }, CultureInfo.InvariantCulture);
var messages = listener.Messages.OrderBy(_ => _.EventId).ToList();
Assert.AreEqual(3, messages[1].EventId);
}
}
public static void ValidateEventLogMessage(TestEventListener listener, string expectedMessage, EventLevel level)
{
bool messageFound = false;
foreach (var actualEvent in listener.Messages.Where((arg) => { return arg.Level == level; }))
{
string actualMessage = string.Format(CultureInfo.InvariantCulture, actualEvent.Message, actualEvent.Payload.ToArray());
messageFound = messageFound || actualMessage.Contains(expectedMessage);
}
Assert.IsTrue(messageFound);
}
public void OnBeginGeneratesWebEventsOnBeginEvent()
{
using (var listener = new TestEventListener())
{
listener.EnableEvents(WebEventsPublisher.Log, EventLevel.LogAlways, (EventKeywords)AllKeywords);
this.module.Invoke("OnBeginRequest", new[] { typeof(object), typeof(EventArgs) }, new object[] { HttpModuleHelper.GetFakeHttpApplication(), null }, CultureInfo.InvariantCulture);
var firstEvent = listener.Messages.FirstOrDefault();
Assert.IsNotNull(firstEvent);
Assert.AreEqual(1, firstEvent.EventId);
}
}
public void OnBeginLogsWarningWhenFailed()
{
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(DependencyCollectorEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeyword);
try
{
this.sqlProcessingProfiler.OnBeginForOneParameter(null);
}
catch (Exception)
{
Assert.Fail("Should not be throwing unhandled exceptions.");
}
TestUtils.ValidateEventLogMessage(listener, "will not run for id", EventLevel.Warning);
}
}
//需要删除的转LuaFunction为委托，不需要删除的直接加或者等于即可
void Awake()
{
state = new LuaState();
state.Start();
LuaBinder.Bind(state);
Bind(state);
state.LogGC = true;
state.DoString(script);
GameObject go = new GameObject("TestGo");
listener = (TestEventListener)go.AddComponent(typeof(TestEventListener));
SetClick1 = state.GetFunction("SetClick1");
AddClick1 = state.GetFunction("AddClick1");
AddClick2 = state.GetFunction("AddClick2");
RemoveClick1 = state.GetFunction("RemoveClick1");
RemoveClick2 = state.GetFunction("RemoveClick2");
TestOverride = state.GetFunction("TestOverride");
}
XDocument Serialize()
{
var x = new XDocument();
var e = new XElement("root");
x.Add(e);
var l1 = new TestEventListener();
var l2 = new TestEventListener();
using (var w = e.CreateWriter())
{
w.WriteWhitespace("");
var s = new EventTargetState();
s.registrations.Add(new EventListenerRegistration("event1", l1, false));
s.registrations.Add(new EventListenerRegistration("event2", l1, true));
s.registrations.Add(new EventListenerRegistration("event1", l2, false));
s.registrations.Add(new EventListenerRegistration("event2", l2, true));
new XmlSerializer(s.GetType()).Serialize(w, s);
}
return x;
}
public void RddTestHttpProcessingProfilerLogsWhenResourceNameIsNullOrEmpty()
{
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(DependencyCollectorEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeyword);
// pass any object other than WebRequest so that Processor will fail to extract any url/name
var request = new object();
DependencyTelemetry operationReturned = (DependencyTelemetry)this.httpProcessingProfiler.OnBeginForGetResponse(request);
Assert.AreEqual(0, this.sendItems.Count, "No telemetry item should be processed without calling End");
TestUtils.ValidateEventLogMessage(listener, "will not run for id", EventLevel.Warning);
}
}
public void NonEventsShouldNotBeLogged()
{
var listener = new TestEventListener();
var testLog = EventSourceImplementer.GetEventSourceAs<INonEvent>();
listener.EnableEvents((EventSource)testLog, EventLevel.LogAlways, (EventKeywords)(-1));
// do some logging
testLog.NonEvent();
testLog.Event();
// look at the events
var events = listener.Events.ToArray();
Assert.AreEqual(1, events.Length);
Assert.AreEqual(99, events[0].EventId);
}
public EventDeal()
{
TestEventSource es = new TestEventSource();
TestEventListener el = new TestEventListener();
}
public void OnEndLogsWarningWhenObjectPassedToEndWithoutCorrespondingBeginAsync()
{
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(DependencyCollectorEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeyword);
try
{
this.sqlProcessingProfiler.OnEndForOneParameter(new object(), new object(), new SqlCommand());
}
catch (Exception)
{
Assert.Fail("Should not be throwing unhandled exceptions.");
}
var message = listener.Messages.First(item => item.EventId == 12);
Assert.IsNotNull(message);
}
}
public void OnBeginLogsWarningWhenPassedThisObjectWithNullConnection()
{
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(DependencyCollectorEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeyword);
try
{
SqlCommand command = new SqlCommand();
this.sqlProcessingProfiler.OnBeginForOneParameter(command);
}
catch (Exception)
{
Assert.Fail("Should not be throwing unhandled exceptions");
}
var message = listener.Messages.First(item => item.EventId == 14);
Assert.IsNotNull(message);
}
}
public async Task Invoke_Works()
{
var events = TestEventListener.Collect();
var httpContext = new DefaultHttpContext();
httpContext.Request.Method = "GET";
httpContext.Request.Scheme = "https";
httpContext.Request.Host = new HostString("example.com");
httpContext.Request.Path = "/api/test";
httpContext.Request.QueryString = new QueryString("?a=b&c=d");
var httpClient = new HttpMessageInvoker(new Mock <HttpMessageHandler>().Object);
var httpRequestOptions = new ForwarderRequestConfig
{
ActivityTimeout = TimeSpan.FromSeconds(60),
Version = HttpVersion.Version11,
VersionPolicy = HttpVersionPolicy.RequestVersionExact,
};
var cluster1 = new ClusterState(clusterId: "cluster1");
var clusterModel = new ClusterModel(new ClusterConfig()
{
HttpRequest = httpRequestOptions
},
httpClient);
var destination1 = cluster1.Destinations.GetOrAdd(
"destination1",
id => new DestinationState(id)
{
Model = new DestinationModel(new DestinationConfig {
Address = "https://localhost:123/a/b/"
})
});
var routeConfig = new RouteModel(
config: new RouteConfig()
{
RouteId = "Route-1"
},
cluster: cluster1,
transformer: HttpTransformer.Default);
httpContext.Features.Set <IReverseProxyFeature>(
new ReverseProxyFeature()
{
AvailableDestinations = new List <DestinationState>()
{
destination1
}.AsReadOnly(),
Cluster = clusterModel,
Route = routeConfig,
});
httpContext.Features.Set(cluster1);
var tcs1 = new TaskCompletionSource <bool>();
var tcs2 = new TaskCompletionSource <bool>();
Mock <IHttpForwarder>()
.Setup(h => h.SendAsync(
httpContext,
It.Is <string>(uri => uri == "https://localhost:123/a/b/"),
httpClient,
It.Is <ForwarderRequestConfig>(requestOptions =>
requestOptions.ActivityTimeout == httpRequestOptions.ActivityTimeout &&
requestOptions.Version == httpRequestOptions.Version &&
requestOptions.VersionPolicy == httpRequestOptions.VersionPolicy),
It.IsAny <HttpTransformer>()))
.Returns(
async() =>
{
tcs1.TrySetResult(true);
await tcs2.Task;
return(ForwarderError.None);
})
.Verifiable();
var sut = Create <ForwarderMiddleware>();
Assert.Equal(0, cluster1.ConcurrencyCounter.Value);
Assert.Equal(0, destination1.ConcurrentRequestCount);
var task = sut.Invoke(httpContext);
if (task.IsFaulted)
{
// Something went wrong, don't hang the test.
await task;
}
Mock <IHttpForwarder>().Verify();
await tcs1.Task; // Wait until we get to the proxying step.
Assert.Equal(1, cluster1.ConcurrencyCounter.Value);
Assert.Equal(1, destination1.ConcurrentRequestCount);
Assert.Same(destination1, httpContext.GetReverseProxyFeature().ProxiedDestination);
tcs2.TrySetResult(true);
await task;
Assert.Equal(0, cluster1.ConcurrencyCounter.Value);
Assert.Equal(0, destination1.ConcurrentRequestCount);
var invoke = Assert.Single(events, e => e.EventName == "ForwarderInvoke");
Assert.Equal(3, invoke.Payload.Count);
Assert.Equal(cluster1.ClusterId, (string)invoke.Payload[0]);
Assert.Equal(routeConfig.Config.RouteId, (string)invoke.Payload[1]);
Assert.Equal(destination1.DestinationId, (string)invoke.Payload[2]);
}
public void AsyncTSTest(int variation)
{
using (var listener = new TestEventListener(new Guid("8ac2d80a-1f1a-431b-ace4-bff8824aef0b"), System.Diagnostics.Tracing.EventLevel.Verbose))
{
var events = new ConcurrentQueue<EventWrittenEventArgs>();
bool success = false;
try
{
listener.RunWithCallback(events.Enqueue, () =>
{
switch (variation)
{
// Running exception test first to make sure any unintentional leak in ambient transaction during exception will be detected when subsequent test are run.
case 0:
{
HandleException(true, false, () => DoSyncTxWork(true, null));
break;
}
case 1:
{
HandleException(true, false, () => AssertTransactionNullAndWaitTask(DoAsyncTxWorkAsync(true, null)));
break;
}
case 2:
{
HandleException(true, false, () => SyncTSL2NestedTxWork(false, false, true, null));
break;
}
case 3:
{
HandleException(false, true, () => AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(false, true, false, true, false, null)));
break;
}
case 4:
{
HandleException(true, false, () => AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(false, true, true, false, false, null)));
break;
}
case 5:
{
HandleException(true, false, () => AssertTransactionNullAndWaitTask(DoAsyncTSL3SyncTSL2NestedTxWorkAsync(false, true, true, false, true, false, null)));
break;
}
case 6:
{
HandleException(false, true, () => AssertTransactionNullAndWaitTask(DoTaskWorkAsync(false, false, null)));
break;
}
case 7:
{
HandleException(false, true, () => SyncTSTaskWork(false, null));
break;
}
// The following test has Task under TransactionScope and has few variations.
case 8:
{
DoTaskUnderAsyncTS(false, null);
break;
}
case 9:
{
Task.Factory.StartNew(() => DoTaskUnderAsyncTS(false, null)).Wait();
break;
}
case 10:
{
SyncTSDoTaskUnderAsyncTS(false, false, null);
break;
}
case 11:
{
SyncTSDoTaskUnderAsyncTS(false, true, null);
break;
}
case 12:
{
Task.Factory.StartNew(() => SyncTSDoTaskUnderAsyncTS(false, true, null)).Wait();
break;
}
// Simple Sync TS test
case 13:
{
DoSyncTxWork(false, null);
break;
}
case 14:
{
DoSyncTxWork(true, null);
break;
}
// Simple Async TS test. "await" points explicitly switches threads across continuations.
case 15:
{
AssertTransactionNullAndWaitTask(DoAsyncTxWorkAsync(false, null));
break;
}
case 16:
{
AssertTransactionNullAndWaitTask(DoAsyncTxWorkAsync(true, null));
break;
}
// Nested TS test. Parent is Sync TS, child TS can be sync or async.
case 17:
{
SyncTSL2NestedTxWork(false, false, false, null);
break;
}
case 18:
{
SyncTSL2NestedTxWork(false, false, true, null);
break;
}
case 19:
{
SyncTSL2NestedTxWork(false, true, false, null);
break;
}
case 20:
{
SyncTSL2NestedTxWork(false, true, true, null);
break;
}
case 21:
{
SyncTSL2NestedTxWork(true, false, false, null);
break;
}
case 22:
{
SyncTSL2NestedTxWork(true, false, true, null);
break;
}
case 23:
{
SyncTSL2NestedTxWork(true, true, false, null);
break;
}
case 24:
{
SyncTSL2NestedTxWork(true, true, true, null);
break;
}
// 2 level deep nested TS test. Parent is Aync TS, child TS can be sync or async.
case 25:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(false, false, false, false, false, null));
break;
}
case 26:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(false, false, true, false, false, null));
break;
}
case 27:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(false, true, false, false, false, null));
break;
}
case 28:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(false, true, true, false, false, null));
break;
}
case 29:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(true, false, false, false, false, null));
break;
}
case 30:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(true, false, true, false, false, null));
break;
}
case 31:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(true, true, false, false, false, null));
break;
}
case 32:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(true, true, true, false, false, null));
break;
}
// Introduce various "await" points to switch threads before/after child TransactionScope.
// Introduce some Task variations by running the test under Task.
case 33:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(false, true, false, true, false, null));
break;
}
case 34:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(false, true, false, false, true, null));
break;
}
case 35:
{
Task.Factory.StartNew(() => AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(false, true, false, false, true, null))).Wait();
break;
}
case 36:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL2NestedTxWorkAsync(false, true, false, true, true, null));
break;
}
// 3 level deep nested TS test.
case 37:
{
SyncTSL3AsyncTSL2NestedTxWork(false, false, true, false, false, true, null);
break;
}
case 38:
{
Task.Factory.StartNew(() => SyncTSL3AsyncTSL2NestedTxWork(false, false, true, false, false, true, null)).Wait();
break;
}
case 39:
{
SyncTSL3AsyncTSL2NestedTxWork(false, false, true, false, true, false, null);
break;
}
case 40:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL3SyncTSL2NestedTxWorkAsync(false, false, false, true, false, false, null));
break;
}
case 41:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL3SyncTSL2NestedTxWorkAsync(false, false, true, false, false, true, null));
break;
}
case 42:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL3SyncTSL2NestedTxWorkAsync(false, false, true, false, true, false, null));
break;
}
case 43:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL3SyncTSL2NestedTxWorkAsync(false, false, true, false, true, true, null));
break;
}
case 44:
{
Task.Factory.StartNew(() => AssertTransactionNullAndWaitTask(DoAsyncTSL3SyncTSL2NestedTxWorkAsync(false, false, true, false, true, true, null))).Wait();
break;
}
case 45:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL3SyncTSL2NestedTxWorkAsync(false, true, true, false, false, true, null));
break;
}
case 46:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL3SyncTSL2NestedTxWorkAsync(false, true, true, false, true, false, null));
break;
}
case 47:
{
AssertTransactionNullAndWaitTask(DoAsyncTSL3SyncTSL2NestedTxWorkAsync(false, true, true, false, true, true, null));
break;
}
case 48:
{
Task.Factory.StartNew(() => AssertTransactionNullAndWaitTask(DoAsyncTSL3SyncTSL2NestedTxWorkAsync(false, true, true, false, true, true, null))).Wait();
break;
}
// Have bunch of parallel tasks running various nested TS test cases. There parallel tasks are wrapped by a TransactionScope.
case 49:
{
AssertTransactionNullAndWaitTask(DoTaskWorkAsync(false, false, null));
break;
}
case 50:
{
SyncTSTaskWork(false, null);
break;
}
case 51:
{
SyncTSTaskWork(true, null);
break;
}
case 52:
{
AssertTransactionNullAndWaitTask(DoAsyncTSTaskWorkAsync(false, false, null));
break;
}
case 53:
{
AssertTransactionNullAndWaitTask(DoAsyncTSTaskWorkAsync(true, false, null));
break;
}
// Final test - wrap the DoAsyncTSTaskWorkAsync in syncronous scope
case 54:
{
string txId1 = null;
string txId2 = null;
using (TransactionScope scope = new TransactionScope())
{
txId1 = AssertAndGetCurrentTransactionId();
Task task = DoAsyncTSTaskWorkAsync(false, false, txId1);
txId2 = AssertAndGetCurrentTransactionId();
task.Wait();
scope.Complete();
}
VerifyTxId(false, null, txId1, txId2);
break;
}
}
});
success = true;
}
finally
{
if (!success)
{
HelperFunctions.DisplaySysTxTracing(output, events);
}
}
}
}
public void EventSource_UnsuccessfulRequest_LogsStartFailedStop(string testMethod)
{
if (UseVersion.Major != 1 && !testMethod.EndsWith("Async"))
{
// Synchronous requests are only supported for HTTP/1.1
return;
}
RemoteExecutor.Invoke(async(useVersionString, testMethod) =>
{
Version version = Version.Parse(useVersionString);
using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d);
listener.AddActivityTracking();
var events = new ConcurrentQueue <(EventWrittenEventArgs Event, Guid ActivityId)>();
await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async() =>
{
var semaphore = new SemaphoreSlim(0, 1);
var cts = new CancellationTokenSource();
await GetFactoryForVersion(version).CreateClientAndServerAsync(
async uri =>
{
using HttpClientHandler handler = CreateHttpClientHandler(useVersionString);
using HttpClient client = CreateHttpClient(handler, useVersionString);
using var invoker = new HttpMessageInvoker(handler);
var request = new HttpRequestMessage(HttpMethod.Get, uri)
{
Version = version
};
switch (testMethod)
{
case "GetAsync":
await Assert.ThrowsAsync <TaskCanceledException>(async() => await client.GetAsync(uri, cts.Token));
break;
case "Send":
await Assert.ThrowsAsync <TaskCanceledException>(async() => await Task.Run(() => client.Send(request, cts.Token)));
break;
case "UnbufferedSend":
await Assert.ThrowsAsync <TaskCanceledException>(async() => await Task.Run(() => client.Send(request, HttpCompletionOption.ResponseHeadersRead, cts.Token)));
break;
case "SendAsync":
await Assert.ThrowsAsync <TaskCanceledException>(async() => await client.SendAsync(request, cts.Token));
break;
case "UnbufferedSendAsync":
await Assert.ThrowsAsync <TaskCanceledException>(async() => await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cts.Token));
break;
case "GetStringAsync":
await Assert.ThrowsAsync <TaskCanceledException>(async() => await client.GetStringAsync(uri, cts.Token));
break;
case "GetByteArrayAsync":
await Assert.ThrowsAsync <TaskCanceledException>(async() => await client.GetByteArrayAsync(uri, cts.Token));
break;
case "GetStreamAsync":
await Assert.ThrowsAsync <TaskCanceledException>(async() => await client.GetStreamAsync(uri, cts.Token));
break;
case "InvokerSend":
await Assert.ThrowsAsync <TaskCanceledException>(async() => await Task.Run(() => invoker.Send(request, cts.Token)));
break;
case "InvokerSendAsync":
await Assert.ThrowsAsync <TaskCanceledException>(async() => await invoker.SendAsync(request, cts.Token));
break;
}
semaphore.Release();
},
async server =>
{
await server.AcceptConnectionAsync(async connection =>
{
await connection.ReadRequestDataAsync();
await WaitForEventCountersAsync(events);
cts.Cancel();
Assert.True(await semaphore.WaitAsync(TimeSpan.FromSeconds(30)));
});
});
await WaitForEventCountersAsync(events);
});
Assert.DoesNotContain(events, e => e.Event.EventId == 0); // errors from the EventSource itself
ValidateStartFailedStopEvents(events, shouldHaveFailures: true);
ValidateConnectionEstablishedClosed(events, version);
ValidateEventCounters(events, requestCount: 1, shouldHaveFailures: true);
}, UseVersion.ToString(), testMethod).Dispose();
}
public void EventSource_SuccessfulRequest_LogsStartStop(string testMethod)
{
if (UseVersion.Major != 1 && !testMethod.EndsWith("Async"))
{
// Synchronous requests are only supported for HTTP/1.1
return;
}
RemoteExecutor.Invoke(async(useVersionString, testMethod) =>
{
const int ResponseContentLength = 42;
Version version = Version.Parse(useVersionString);
using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d);
listener.AddActivityTracking();
bool buffersResponse = false;
var events = new ConcurrentQueue <(EventWrittenEventArgs Event, Guid ActivityId)>();
await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async() =>
{
await GetFactoryForVersion(version).CreateClientAndServerAsync(
async uri =>
{
using HttpClientHandler handler = CreateHttpClientHandler(useVersionString);
using HttpClient client = CreateHttpClient(handler, useVersionString);
using var invoker = new HttpMessageInvoker(handler);
var request = new HttpRequestMessage(HttpMethod.Get, uri)
{
Version = version
};
switch (testMethod)
{
case "GetAsync":
{
buffersResponse = true;
await client.GetAsync(uri);
}
break;
case "Send":
{
buffersResponse = true;
await Task.Run(() => client.Send(request));
}
break;
case "UnbufferedSend":
{
buffersResponse = false;
HttpResponseMessage response = await Task.Run(() => client.Send(request, HttpCompletionOption.ResponseHeadersRead));
response.Content.CopyTo(Stream.Null, null, default);
}
break;
case "SendAsync":
{
buffersResponse = true;
await client.SendAsync(request);
}
break;
case "UnbufferedSendAsync":
{
buffersResponse = false;
HttpResponseMessage response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
await response.Content.CopyToAsync(Stream.Null);
}
break;
case "GetStringAsync":
{
buffersResponse = true;
await client.GetStringAsync(uri);
}
break;
case "GetByteArrayAsync":
{
buffersResponse = true;
await client.GetByteArrayAsync(uri);
}
break;
case "GetStreamAsync":
{
buffersResponse = false;
Stream responseStream = await client.GetStreamAsync(uri);
await responseStream.CopyToAsync(Stream.Null);
}
break;
case "InvokerSend":
{
buffersResponse = false;
HttpResponseMessage response = await Task.Run(() => invoker.Send(request, cancellationToken: default));
await response.Content.CopyToAsync(Stream.Null);
}
break;
case "InvokerSendAsync":
{
buffersResponse = false;
HttpResponseMessage response = await invoker.SendAsync(request, cancellationToken: default);
await response.Content.CopyToAsync(Stream.Null);
}
break;
}
},
async server =>
{
await server.AcceptConnectionAsync(async connection =>
{
await WaitForEventCountersAsync(events);
await connection.ReadRequestDataAsync();
await connection.SendResponseAsync(content: new string('a', ResponseContentLength));
});
});
await WaitForEventCountersAsync(events);
});
Assert.DoesNotContain(events, e => e.Event.EventId == 0); // errors from the EventSource itself
ValidateStartFailedStopEvents(events);
ValidateConnectionEstablishedClosed(events, version);
ValidateRequestResponseStartStopEvents(
events,
requestContentLength: null,
responseContentLength: buffersResponse ? ResponseContentLength : null,
count: 1);
ValidateEventCounters(events, requestCount: 1, shouldHaveFailures: false);
}, UseVersion.ToString(), testMethod).Dispose();
}
public void Setup()
{
_listener = new TestEventListener();
_listener.EnableEvents(AzureIdentityEventSource.Singleton, EventLevel.Verbose);
}
public async Task Invoke_Works()
{
var events = TestEventListener.Collect();
var httpContext = new DefaultHttpContext();
httpContext.Request.Method = "GET";
httpContext.Request.Scheme = "https";
httpContext.Request.Host = new HostString("example.com");
httpContext.Request.Path = "/api/test";
httpContext.Request.QueryString = new QueryString("?a=b&c=d");
var httpClient = new HttpMessageInvoker(new Mock <HttpMessageHandler>().Object);
var httpRequestOptions = new RequestProxyOptions
{
Timeout = TimeSpan.FromSeconds(60),
Version = HttpVersion.Version11,
#if NET
VersionPolicy = HttpVersionPolicy.RequestVersionExact,
#endif
};
var cluster1 = new ClusterInfo(
clusterId: "cluster1",
destinationManager: new DestinationManager());
var clusterConfig = new ClusterConfig(new Cluster()
{
HttpRequest = httpRequestOptions
},
httpClient);
var destination1 = cluster1.DestinationManager.GetOrCreateItem(
"destination1",
destination =>
{
destination.Config = new DestinationConfig("https://localhost:123/a/b/", null);
});
httpContext.Features.Set <IReverseProxyFeature>(
new ReverseProxyFeature()
{
AvailableDestinations = new List <DestinationInfo>()
{
destination1
}.AsReadOnly(), ClusterConfig = clusterConfig
});
httpContext.Features.Set(cluster1);
var aspNetCoreEndpoints = new List <Endpoint>();
var routeConfig = new RouteConfig(
route: new RouteInfo("route1"),
proxyRoute: new ProxyRoute(),
cluster: cluster1,
transformer: null);
var aspNetCoreEndpoint = CreateAspNetCoreEndpoint(routeConfig);
aspNetCoreEndpoints.Add(aspNetCoreEndpoint);
httpContext.SetEndpoint(aspNetCoreEndpoint);
var tcs1 = new TaskCompletionSource <bool>();
var tcs2 = new TaskCompletionSource <bool>();
Mock <IHttpProxy>()
.Setup(h => h.ProxyAsync(
httpContext,
It.Is <string>(uri => uri == "https://localhost:123/a/b/"),
httpClient,
It.Is <RequestProxyOptions>(requestOptions =>
requestOptions.Timeout == httpRequestOptions.Timeout &&
requestOptions.Version == httpRequestOptions.Version
#if NET
&& requestOptions.VersionPolicy == httpRequestOptions.VersionPolicy
#endif
),
It.Is <HttpTransformer>(transformer => transformer == null)))
.Returns(
async() =>
{
tcs1.TrySetResult(true);
await tcs2.Task;
})
.Verifiable();
var sut = Create <ProxyInvokerMiddleware>();
Assert.Equal(0, cluster1.ConcurrencyCounter.Value);
Assert.Equal(0, destination1.ConcurrencyCounter.Value);
var task = sut.Invoke(httpContext);
if (task.IsFaulted)
{
// Something went wrong, don't hang the test.
await task;
}
Mock <IHttpProxy>().Verify();
await tcs1.Task; // Wait until we get to the proxying step.
Assert.Equal(1, cluster1.ConcurrencyCounter.Value);
Assert.Equal(1, destination1.ConcurrencyCounter.Value);
Assert.Same(destination1, httpContext.GetRequiredProxyFeature().SelectedDestination);
tcs2.TrySetResult(true);
await task;
Assert.Equal(0, cluster1.ConcurrencyCounter.Value);
Assert.Equal(0, destination1.ConcurrencyCounter.Value);
var invoke = Assert.Single(events, e => e.EventName == "ProxyInvoke");
Assert.Equal(3, invoke.Payload.Count);
Assert.Equal(cluster1.ClusterId, (string)invoke.Payload[0]);
Assert.Equal(routeConfig.Route.RouteId, (string)invoke.Payload[1]);
Assert.Equal(destination1.DestinationId, (string)invoke.Payload[2]);
}
public void TestEtw()
{
using (var listener = new TestEventListener(new Guid("16F53577-E41D-43D4-B47E-C17025BF4025"), EventLevel.Verbose))
{
ActionBlock <int> ab = null;
BufferBlock <int> bb = null;
int remaining = 0;
CountdownEvent ce = new CountdownEvent(0);
// Check that block creation events fire
const int DataflowBlockCreatedId = 1;
remaining = 2;
listener.RunWithCallback(ev => {
Assert.Equal(expected: DataflowBlockCreatedId, actual: ev.EventId);
remaining--;
},
() => {
ab = new ActionBlock <int>(i => { });
bb = new BufferBlock <int>(); // trigger block creation event
Assert.Equal(expected: 0, actual: remaining);
});
// Check that linking events fire
const int BlockLinkedId = 4;
remaining = 1;
IDisposable link = null;
listener.RunWithCallback(ev => {
Assert.Equal(expected: BlockLinkedId, actual: ev.EventId);
remaining--;
},
() => {
link = bb.LinkTo(ab);
Assert.Equal(expected: 0, actual: remaining);
});
// Check that unlinking events fire
const int BlockUnlinkedId = 5;
remaining = 1;
listener.RunWithCallback(ev => {
Assert.Equal(expected: BlockUnlinkedId, actual: ev.EventId);
remaining--;
},
() => {
link.Dispose();
Assert.Equal(expected: 0, actual: remaining);
});
// Bug: It appears that private reflection problems are causing events with enum arguments
// to fail to fire on .NET Core. Needs further investigation. The following
// two tests are disabled as a result.
//// Check that task launched events fire
//const int TaskLaunchedId = 2;
//ce.Reset(1);
//listener.RunWithCallback(ev => {
// Assert.Equal(expected: TaskLaunchedId, actual: ev.EventId);
// ce.Signal();
// },
// () => {
// ab.Post(42);
// ce.Wait();
// Assert.Equal(expected: 0, actual: ce.CurrentCount);
// });
//// Check that completion events fire
//const int BlockCompletedId = 3;
//ce.Reset(2);
//listener.RunWithCallback(ev => {
// Assert.Equal(expected: BlockCompletedId, actual: ev.EventId);
// ce.Signal();
// },
// () => {
// ab.Complete();
// bb.Complete();
// ce.Wait();
// Assert.Equal(expected: 0, actual: ce.CurrentCount);
// });
}
}
public void Setup()
{
_listener = new TestEventListener();
_listener.EnableEvents(SchemaRegistryAvroEventSource.Log, EventLevel.Verbose);
}
public void StopLoggingEvents()
{
s_listener?.Dispose();
s_listener = null;
}
public void RddTestHttpProcessingProfilerOnEndForGetResponseFailed()
{
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(DependencyCollectorEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeyword);
var returnObjectPassed = new object();
var request = WebRequest.Create(this.testUrl);
DependencyTelemetry operationReturned = (DependencyTelemetry)this.httpProcessingProfiler.OnBeginForGetResponse(request);
var objectReturned = this.httpProcessingProfiler.OnEndForGetResponse(null, returnObjectPassed, null);
Assert.AreSame(returnObjectPassed, objectReturned, "Object returned from OnEndForGetResponse processor is not the same as expected return object");
Assert.AreEqual(0, this.sendItems.Count, "No telemetry item should be processed without calling End");
var message = listener.Messages.First(item => item.EventId == 14);
Assert.IsNotNull(message);
}
}
public void RddTestSqlProcessingProfilerOnBeginForExecuteReaderFailed()
{
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(DependencyCollectorEventSource.Log, EventLevel.Verbose, (EventKeywords)AllKeyword);
try
{
SqlCommand command = null;
DependencyTelemetry operationReturned = (DependencyTelemetry)this.sqlProcessingProfiler.OnBeginForExecuteReader(command, null, null);
}
catch (Exception)
{
Assert.Fail("sqlProcessingProfiler should not be throwing unhandled exceptions");
}
TestUtils.ValidateEventLogMessage(listener, "will not run for id", EventLevel.Warning);
}
}
public void TestEtw()
{
using (var listener = new TestEventListener(new Guid("16F53577-E41D-43D4-B47E-C17025BF4025"), EventLevel.Verbose))
{
ActionBlock <int> ab = null;
BufferBlock <int> bb = null;
int remaining = 0;
CountdownEvent ce = new CountdownEvent(0);
// Check that block creation events fire
const int DataflowBlockCreatedId = 1;
remaining = 2;
listener.RunWithCallback(ev => {
Assert.Equal(expected: DataflowBlockCreatedId, actual: ev.EventId);
remaining--;
},
() => {
ab = new ActionBlock <int>(i => { });
bb = new BufferBlock <int>(); // trigger block creation event
Assert.Equal(expected: 0, actual: remaining);
});
// Check that linking events fire
const int BlockLinkedId = 4;
remaining = 1;
IDisposable link = null;
listener.RunWithCallback(ev => {
Assert.Equal(expected: BlockLinkedId, actual: ev.EventId);
remaining--;
},
() => {
link = bb.LinkTo(ab);
Assert.Equal(expected: 0, actual: remaining);
});
// Check that unlinking events fire
const int BlockUnlinkedId = 5;
remaining = 1;
listener.RunWithCallback(ev => {
Assert.Equal(expected: BlockUnlinkedId, actual: ev.EventId);
remaining--;
},
() => {
link.Dispose();
Assert.Equal(expected: 0, actual: remaining);
});
// Check that task launched events fire
const int TaskLaunchedId = 2;
ce.Reset(1);
listener.RunWithCallback(ev => {
Assert.Equal(expected: TaskLaunchedId, actual: ev.EventId);
ce.Signal();
},
() => {
ab.Post(42);
ce.Wait();
Assert.Equal(expected: 0, actual: ce.CurrentCount);
});
// Check that completion events fire
const int BlockCompletedId = 3;
ce.Reset(2);
listener.RunWithCallback(ev => {
Assert.Equal(expected: BlockCompletedId, actual: ev.EventId);
ce.Signal();
},
() => {
ab.Complete();
bb.Complete();
ce.Wait();
Assert.Equal(expected: 0, actual: ce.CurrentCount);
});
}
}
public void RddTestSqlProcessingProfilerBeginExecuteXmlReaderInternalFailedOnStart()
{
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(DependencyCollectorEventSource.Log, EventLevel.Verbose, (EventKeywords)AllKeyword);
try
{
this.sqlProcessingProfiler.OnBeginForBeginExecuteXmlReaderInternal(null, null, null, null, null);
}
catch (Exception)
{
Assert.Fail("sqlProcessingProfiler should not be throwing unhandled exceptions");
}
TestUtils.ValidateEventLogMessage(listener, "will not run for id", EventLevel.Warning);
}
}
public void EventSource_SuccessfulRequest_LogsStartStop(string testMethod)
{
if (UseVersion.Major != 1 && !testMethod.EndsWith("Async"))
{
// Synchronous requests are only supported for HTTP/1.1
return;
}
RemoteExecutor.Invoke(async(useVersionString, testMethod) =>
{
const int ResponseContentLength = 42;
Version version = Version.Parse(useVersionString);
using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d);
var events = new ConcurrentQueue <EventWrittenEventArgs>();
await listener.RunWithCallbackAsync(events.Enqueue, async() =>
{
await GetFactoryForVersion(version).CreateClientAndServerAsync(
async uri =>
{
using HttpClientHandler handler = CreateHttpClientHandler(useVersionString);
using HttpClient client = CreateHttpClient(handler, useVersionString);
using var invoker = new HttpMessageInvoker(handler);
var request = new HttpRequestMessage(HttpMethod.Get, uri)
{
Version = version
};
switch (testMethod)
{
case "GetAsync":
await client.GetAsync(uri);
break;
case "Send":
await Task.Run(() => client.Send(request));
break;
case "SendAsync":
await client.SendAsync(request);
break;
case "GetStringAsync":
await client.GetStringAsync(uri);
break;
case "GetByteArrayAsync":
await client.GetByteArrayAsync(uri);
break;
case "GetStreamAsync":
Stream responseStream = await client.GetStreamAsync(uri);
await responseStream.CopyToAsync(Stream.Null);
break;
case "InvokerSend":
HttpResponseMessage syncResponse = await Task.Run(() => invoker.Send(request, cancellationToken: default));
await syncResponse.Content.CopyToAsync(Stream.Null);
break;
case "InvokerSendAsync":
HttpResponseMessage asyncResponse = await invoker.SendAsync(request, cancellationToken: default);
await asyncResponse.Content.CopyToAsync(Stream.Null);
break;
}
},
async server =>
{
await server.AcceptConnectionAsync(async connection =>
{
await Task.Delay(300);
await connection.ReadRequestDataAsync();
await connection.SendResponseAsync(content: new string('a', ResponseContentLength));
});
});
await Task.Delay(300);
});
Assert.DoesNotContain(events, ev => ev.EventId == 0); // errors from the EventSource itself
EventWrittenEventArgs start = Assert.Single(events, e => e.EventName == "RequestStart");
ValidateStartEventPayload(start);
EventWrittenEventArgs stop = Assert.Single(events, e => e.EventName == "RequestStop");
Assert.Empty(stop.Payload);
Assert.DoesNotContain(events, e => e.EventName == "RequestFailed");
ValidateConnectionEstablishedClosed(events, version);
ValidateRequestResponseStartStopEvents(
events,
requestContentLength: null,
responseContentLength: testMethod.StartsWith("InvokerSend") ? null : ResponseContentLength,
count: 1);
VerifyEventCounters(events, requestCount: 1, shouldHaveFailures: false);
}, UseVersion.ToString(), testMethod).Dispose();
public void RddTestSqlProcessingProfilerLogsResourceNameNull()
{
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(DependencyCollectorEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeyword);
try
{
SqlCommand command = new SqlCommand();
this.sqlProcessingProfiler.OnBeginForBeginExecuteXmlReaderInternal(command, null, null, null, null);
}
catch (Exception)
{
Assert.Fail("sqlProcessingProfiler should not be throwing unhandled exceptions");
}
var message = listener.Messages.First(item => item.EventId == 14);
Assert.IsNotNull(message);
}
}
public void HandlesSyncExceptionThrownByTheDelegate()
{
TaskTimer timer = new TaskTimer { Delay = TimeSpan.FromMilliseconds(1) };
using (TestEventListener listener = new TestEventListener())
{
listener.EnableEvents(CoreEventSource.Log, EventLevel.LogAlways);
timer.Start(() => { throw new Exception(); });
Assert.NotNull(listener.Messages.FirstOrDefault());
}
}
public void RddTestSqlProcessingProfilerLogsWhenObjectPassedToEndWithoutCorrespondingBeginAsync()
{
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(DependencyCollectorEventSource.Log, EventLevel.Verbose, (EventKeywords)AllKeyword);
try
{
var objectReturned = this.sqlProcessingProfiler.OnEndForSqlAsync(new object(), null, new SqlCommand(), null);
}
catch (Exception)
{
Assert.Fail("sqlProcessingProfiler should not be throwing unhandled exceptions");
}
var message = listener.Messages.First(item => item.EventId == 12);
Assert.IsNotNull(message);
}
}
public void EnableEventSource()
{
_listener = new TestEventListener(_events);
_listener.EnableEvents(NpgsqlSqlEventSource.Log, EventLevel.Informational);
}
public static void DroppedIncompleteStateMachine_RaisesIncompleteAsyncMethodEvent()
{
RemoteExecutor.Invoke(() =>
{
using (var listener = new TestEventListener("System.Threading.Tasks.TplEventSource", EventLevel.Verbose))
{
var events = new ConcurrentQueue <EventWrittenEventArgs>();
listener.RunWithCallback(events.Enqueue, () =>
{
NeverCompletes();
GC.Collect();
GC.WaitForPendingFinalizers();
GC.WaitForPendingFinalizers();
});
// To help diagnose https://github.com/dotnet/runtime/issues/2198
// Assert.DoesNotContain(events, ev => ev.EventId == 0); // errors from the EventSource itself
var sb = new StringBuilder();
foreach (EventWrittenEventArgs ev in events)
{
if (ev.EventId == 0)
{
sb.AppendLine("Events contained unexpected event:")
.AppendLine($"ActivityId: {ev.ActivityId}")
.AppendLine($"Channel: {ev.Channel}")
.AppendLine($"EventId: {ev.EventId}")
.AppendLine($"EventName: {ev.EventName}")
.AppendLine($"EventSource: {ev.EventSource}")
.AppendLine($"Keywords: {ev.Keywords}")
.AppendLine($"Level: {ev.Level}")
.AppendLine($"Message: {ev.Message}")
.AppendLine($"Opcode: {ev.Opcode}")
.AppendLine($"OSThreadId: {ev.OSThreadId}")
.AppendLine($"Payload: {(ev.Payload != null ? string.Join(", ", ev.Payload) : "(null)")}")
.AppendLine($"PayloadNames: {(ev.PayloadNames != null ? string.Join(", ", ev.PayloadNames) : "(null)")}")
.AppendLine($"RelatedActivityId: {ev.RelatedActivityId}")
.AppendLine($"Tags: {ev.Tags}")
.AppendLine($"Task: {ev.Task}")
.AppendLine($"TimeStamp: {ev.TimeStamp}")
.AppendLine($"Version: {ev.Version}")
.AppendLine();
}
}
if (sb.Length > 0)
{
throw new XunitException(sb.ToString());
}
EventWrittenEventArgs iam = events.SingleOrDefault(e => e.EventName == "IncompleteAsyncMethod");
Assert.NotNull(iam);
Assert.NotNull(iam.Payload);
string description = iam.Payload[0] as string;
Assert.NotNull(description);
Assert.Contains(nameof(NeverCompletesAsync), description);
Assert.Contains("__state", description);
Assert.Contains("local1", description);
Assert.Contains("local2", description);
Assert.Contains("42", description);
Assert.Contains("stored data", description);
}
}).Dispose();
}
private static void CatchesAndLogsExceptionThrownByTransmitter(ErrorHandlingTransmissionPolicy policy, StubTransmitter transmitter, Exception exception)
{
policy.Initialize(transmitter);
using (var listener = new TestEventListener())
{
const long AllKeywords = -1;
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeywords);
transmitter.OnTransmissionSent(new TransmissionProcessedEventArgs(new StubTransmission(), CreateException(statusCode: 408)));
EventWrittenEventArgs error = listener.Messages.First(args => args.EventId == 23);
Assert.Contains(exception.Message, (string)error.Payload[1], StringComparison.Ordinal);
}
}
public void HandlesExceptionsThrownByNetworkIsAvailable()
{
using (var listener = new TestEventListener())
{
const long AllKeywords = -1;
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeywords);
var exception = new Exception("Socket Error");
var network = new StubNetwork { OnIsAvailable = () => { throw exception; } };
var policy = new NetworkAvailabilityTransmissionPolicy(network);
policy.Initialize(new StubTransmitter());
network.OnStatusChanged(EventArgs.Empty);
EventWrittenEventArgs error = listener.Messages.First();
Assert.Contains(exception.Message, (string)error.Payload[0], StringComparison.Ordinal);
}
}
public void TrackLogsDiagnosticsMessageOnExceptionsDuringTelemetryIntializersInitialize()
{
using (var listener = new TestEventListener())
{
listener.EnableEvents(CoreEventSource.Log, EventLevel.Error);
var configuration = new TelemetryConfiguration { InstrumentationKey = "Test key", TelemetryChannel = new StubTelemetryChannel() };
var telemetryInitializer = new StubTelemetryInitializer();
var exceptionMessage = "Test exception message";
telemetryInitializer.OnInitialize = item => { throw new Exception(exceptionMessage); };
configuration.TelemetryInitializers.Add(telemetryInitializer);
var client = new TelemetryClient(configuration);
client.Track(new StubTelemetry());
var exceptionExplanation = "Exception while initializing " + typeof(StubTelemetryInitializer).FullName;
var diagnosticsMessage = (string)listener.Messages.First().Payload[0];
Assert.Contains(exceptionExplanation, diagnosticsMessage, StringComparison.OrdinalIgnoreCase);
Assert.Contains(exceptionMessage, diagnosticsMessage, StringComparison.OrdinalIgnoreCase);
}
}
public void CannotParseRetryAfterWritesToEventSource()
{
const string UnparsableDate = "no one can parse me! :)";
var transmitter = new StubTransmitter();
var policy = new ThrottlingTransmissionPolicy();
policy.Initialize(transmitter);
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.LogAlways, (EventKeywords)AllKeyword);
transmitter.OnTransmissionSent(
new TransmissionProcessedEventArgs(
new StubTransmission(),
CreateThrottledResponse(ResponseCodeTooManyRequests, UnparsableDate)));
EventWrittenEventArgs trace = listener.Messages.First(args => args.EventId == 24);
Assert.Equal(UnparsableDate, (string)trace.Payload[0]);
}
}
public async Task LongContentTransfer_TelemetryReportsTransferringEvents(bool isRequest)
{
var events = TestEventListener.Collect();
const int SourceSize = 123;
var sourceBytes = new byte[SourceSize];
var source = new MemoryStream(sourceBytes);
var destination = new MemoryStream();
var clock = new ManualClock();
var sourceWaitTime = TimeSpan.FromMilliseconds(789); // Every second read triggers ContentTransferring
var destinationWaitTime = TimeSpan.FromMilliseconds(42);
const int BytesPerRead = 3;
var contentReads = (int)Math.Ceiling((double)SourceSize / BytesPerRead);
using var cts = new CancellationTokenSource();
await StreamCopier.CopyAsync(
isRequest,
new SlowStream(source, clock, sourceWaitTime) { MaxBytesPerRead = BytesPerRead },
new SlowStream(destination, clock, destinationWaitTime),
clock,
cts,
TimeSpan.FromSeconds(10));
Assert.Equal(sourceBytes, destination.ToArray());
AssertContentTransferred(events, isRequest, SourceSize,
iops: contentReads + 1,
firstReadTime: sourceWaitTime,
readTime: (contentReads + 1) * sourceWaitTime,
writeTime: contentReads * destinationWaitTime);
var transferringEvents = events.Where(e => e.EventName == "ContentTransferring").ToArray();
Assert.Equal(contentReads / 2, transferringEvents.Length);
for (var i = 0; i < transferringEvents.Length; i++)
{
var payload = transferringEvents[i].Payload;
Assert.Equal(5, payload.Count);
Assert.Equal(isRequest, (bool)payload[0]);
var contentLength = (long)payload[1];
var iops = (long)payload[2];
Assert.Equal((i + 1) * 2, iops);
if (contentLength % BytesPerRead == 0)
{
Assert.Equal(iops * BytesPerRead, contentLength);
}
else
{
Assert.Equal(transferringEvents.Length - 1, i);
Assert.Equal(SourceSize, contentLength);
}
var readTime = new TimeSpan((long)payload[3]);
Assert.Equal(iops * sourceWaitTime, readTime, new ApproximateTimeSpanComparer());
var writeTime = new TimeSpan((long)payload[4]);
Assert.Equal(iops * destinationWaitTime, writeTime, new ApproximateTimeSpanComparer());
}
}
public void LogsUnhandledAsyncExceptionsToPreventThemFromCrashingApplication()
{
var exception = new Exception(Guid.NewGuid().ToString());
var buffer = new StubTransmissionBuffer
{
OnEnqueue = getTransmissionAsync =>
{
throw exception;
}
};
Transmitter transmitter = CreateTransmitter(buffer: buffer);
using (var listener = new TestEventListener())
{
const long AllKeywords = -1;
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeywords);
buffer.OnTransmissionDequeued(new TransmissionProcessedEventArgs(new StubTransmission()));
EventWrittenEventArgs message = listener.Messages.First();
Assert.Contains(exception.Message, (string)message.Payload[0], StringComparison.Ordinal);
}
}
public void RddTestHttpProcessingProfilerOnBeginForGetResponseFailed()
{
using (var listener = new TestEventListener())
{
const long AllKeyword = -1;
listener.EnableEvents(DependencyCollectorEventSource.Log, EventLevel.Verbose, (EventKeywords)AllKeyword);
var request = WebRequest.Create(this.testUrl);
DependencyTelemetry operationReturned = (DependencyTelemetry)this.httpProcessingProfiler.OnBeginForGetResponse(null);
Assert.AreEqual(0, this.sendItems.Count, "No telemetry item should be processed without calling End");
TestUtils.ValidateEventLogMessage(listener, "will not run for id", EventLevel.Warning);
}
}
public void ErrorLoggedIfHandlerThrowsException()
{
var handlers = new Dictionary<int, Action<EventWrittenEventArgs>>();
handlers.Add(1, args => { throw new ApplicationException(); });
using (new WebEventsSubscriber(handlers))
{
using (var listener = new TestEventListener())
{
listener.EnableEvents(WebEventSource.Log, EventLevel.Error, (EventKeywords)AllKeywords);
WebEventsPublisher.Log.OnBegin();
var firstEvent = listener.Messages.FirstOrDefault();
Assert.IsNotNull(firstEvent);
Assert.AreEqual(4, firstEvent.EventId);
}
}
}
public void Setup()
{
_listener = new TestEventListener();
_listener.EnableEvents(ServiceBusEventSource.Log, EventLevel.Verbose);
}
static int SetOnFinished(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 2 && ToLua.CheckTypes(L, 1, typeof(TestEventListener), typeof(TestEventListener.VoidDelegate)))
{
TestEventListener obj = (TestEventListener)ToLua.ToObject(L, 1);
TestEventListener.VoidDelegate arg0 = null;
LuaTypes funcType2 = LuaDLL.lua_type(L, 2);
if (funcType2 != LuaTypes.LUA_TFUNCTION)
{
arg0 = (TestEventListener.VoidDelegate)ToLua.ToObject(L, 2);
}
else
{
LuaFunction func = ToLua.ToLuaFunction(L, 2);
arg0 = DelegateFactory.CreateDelegate(L, typeof(TestEventListener.VoidDelegate), func) as TestEventListener.VoidDelegate;
}
try
{
obj.SetOnFinished(arg0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
return(0);
}
else if (count == 2 && ToLua.CheckTypes(L, 1, typeof(TestEventListener), typeof(TestEventListener.OnClick)))
{
TestEventListener obj = (TestEventListener)ToLua.ToObject(L, 1);
TestEventListener.OnClick arg0 = null;
LuaTypes funcType2 = LuaDLL.lua_type(L, 2);
if (funcType2 != LuaTypes.LUA_TFUNCTION)
{
arg0 = (TestEventListener.OnClick)ToLua.ToObject(L, 2);
}
else
{
LuaFunction func = ToLua.ToLuaFunction(L, 2);
arg0 = DelegateFactory.CreateDelegate(L, typeof(TestEventListener.OnClick), func) as TestEventListener.OnClick;
}
try
{
obj.SetOnFinished(arg0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
return(0);
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: TestEventListener.SetOnFinished");
}
return(0);
}
public void HandlesExceptionsThrownByNetworkWhenAddingAddressChangedEventHandler()
{
using (var listener = new TestEventListener())
{
const long AllKeywords = -1;
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeywords);
var exception = new SocketException();
var network = new StubNetwork { OnAddAddressChangedEventHandler = handler => { throw exception; } };
var policy = new NetworkAvailabilityTransmissionPolicy(network);
policy.Initialize(new StubTransmitter());
EventWrittenEventArgs error = listener.Messages.First(arg => arg.EventId == 38);
Assert.Contains(exception.Message, (string)error.Payload[0], StringComparison.CurrentCulture);
}
}
public void DoesNotLogErrorsIfCallbackReturnsNull()
{
using (TestEventListener listener = new TestEventListener())
{
listener.EnableEvents(CoreEventSource.Log, EventLevel.Error);
var timer = new TaskTimer {Delay = TimeSpan.FromMilliseconds(1)};
var actionInvoked = new ManualResetEventSlim();
timer.Start(() => { actionInvoked.Set(); return null; });
Assert.True(actionInvoked.Wait(50));
Thread.Sleep(1000);
Assert.Null(listener.Messages.FirstOrDefault());
}
}
public void TracesDiagnosticsEvent()
{
Transmitter transmitter = CreateTransmitter();
using (var listener = new TestEventListener())
{
const long AllKeywords = -1;
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.LogAlways, (EventKeywords)AllKeywords);
transmitter.Enqueue(new StubTransmission());
EventWrittenEventArgs trace = listener.Messages.First();
Assert.Equal(21, trace.EventId);
}
}
private static void VerifyEvents(TestEventListener eventListener, params string[] verifierIDs)
{
Assert.Collection(eventListener.Events, verifierIDs.Select(id => EventVerifiers[id]).ToArray());
}
public void Setup()
{
_listener = new TestEventListener();
_listener.EnableEvents(HttpPipelineEventSource.Singleton, EventLevel.Verbose);
}
public void Setup()
{
_listener = new TestEventListener();
_listener.EnableEvents(CertificatesEventSource.Singleton, EventLevel.Verbose);
}
