private HttpContext GetHttpContext()
{
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(s => s.GetService(typeof(ILogger <ViewResult>)))
.Returns(new Mock <ILogger <ViewResult> >().Object);
var optionsAccessor = new Mock <IOptions <MvcViewOptions> >();
optionsAccessor.SetupGet(o => o.Value)
.Returns(new MvcViewOptions());
serviceProvider.Setup(s => s.GetService(typeof(IOptions <MvcViewOptions>)))
.Returns(optionsAccessor.Object);
var telemetry = new TelemetryListener("Microsoft.AspNet");
serviceProvider.Setup(s => s.GetService(typeof(TelemetryListener)))
.Returns(telemetry);
serviceProvider.Setup(s => s.GetService(typeof(TelemetrySource)))
.Returns(telemetry);
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = serviceProvider.Object;
return(httpContext);
}
public void Completed()
{
var result = new List <KeyValuePair <string, object> >();
var observer = new ObserverToList <TelemData>(result);
var listener = new TelemetryListener("MyListener");
var subscription = listener.Subscribe(observer);
listener.WriteTelemetry("IntPayload", 5);
Assert.Equal(1, result.Count);
Assert.Equal("IntPayload", result[0].Key);
Assert.Equal(5, result[0].Value);
Assert.False(observer.Completed);
// The listener dies
listener.Dispose();
Assert.True(observer.Completed);
// confirm that we can unsubscribe without crashing
subscription.Dispose();
// If we resubscribe after dispose, but it does not do anything.
subscription = listener.Subscribe(observer);
listener.WriteTelemetry("IntPayload", 5);
Assert.Equal(1, result.Count);
}
public void ListenerToString()
{
string name = Guid.NewGuid().ToString();
using (var listener = new TelemetryListener(name))
{
Assert.Equal(name, listener.ToString());
}
}
public void AllListenersAddRemove()
{
// This callback will return the listener that happens on the callback
TelemetryListener returnedListener = null;
Action<TelemetryListener> onNewListener = delegate (TelemetryListener listener)
{
Assert.Null(returnedListener);
Assert.NotNull(listener);
returnedListener = listener;
};
// Subscribe, which delivers catch-up event for the Default listener
using (var allListenerSubscription = TelemetryListener.AllListeners.Subscribe(MakeObserver(onNewListener)))
{
Assert.Equal(TelemetryListener.DefaultListener, returnedListener);
returnedListener = null;
} // Now we unsubscribe
// Create an dispose a listener, but we won't get a callback for it.
using (new TelemetryListener("TestListen"))
{ }
Assert.Null(returnedListener); // No callback was made
// Resubscribe
using (var allListenerSubscription = TelemetryListener.AllListeners.Subscribe(MakeObserver(onNewListener)))
{
Assert.Equal(TelemetryListener.DefaultListener, returnedListener);
returnedListener = null;
// add two new subscribers
using (var listener1 = new TelemetryListener("TestListen1"))
{
Assert.Equal(listener1.Name, "TestListen1");
Assert.Equal(listener1, returnedListener);
returnedListener = null;
using (var listener2 = new TelemetryListener("TestListen2"))
{
Assert.Equal(listener2.Name, "TestListen2");
Assert.Equal(listener2, returnedListener);
returnedListener = null;
} // Dispose of listener2
} // Dispose of listener1
} // Unsubscribe
// Check that we are back to just the DefaultListener.
using (var allListenerSubscription = TelemetryListener.AllListeners.Subscribe(MakeObserver(onNewListener)))
{
Assert.Equal(TelemetryListener.DefaultListener, returnedListener);
returnedListener = null;
} // cleanup
}
public WindCompass()
{
InitializeComponent();
ResizeRedraw = true;
Arrow = Properties.Resources.ArrowLarge;
WindDirection = 0;
telemetry = new TelemetryListener();
telemetry.TelemetryDataUpdated += telemetry_TelemetryDataUpdated;
telemetry.SessionDataUpdated += telemetry_SessionDataUpdated;
}
public async Task ExecuteResultAsync_UsesCompositeViewEngineFromServices_IfViewEngineIsNotSpecified()
{
// Arrange
var viewName = "some-view-name";
var context = new ActionContext(new DefaultHttpContext(),
new RouteData(),
new ActionDescriptor {
Name = viewName
});
var viewEngine = new Mock <ICompositeViewEngine>();
viewEngine.Setup(e => e.FindView(context, viewName))
.Returns(ViewEngineResult.Found(viewName, Mock.Of <IView>()))
.Verifiable();
var serviceProvider = new Mock <IServiceProvider>();
var telemetry = new TelemetryListener("Microsoft.AspNet");
serviceProvider
.Setup(s => s.GetService(typeof(TelemetrySource)))
.Returns(telemetry);
serviceProvider
.Setup(s => s.GetService(typeof(TelemetryListener)))
.Returns(telemetry);
serviceProvider.Setup(p => p.GetService(typeof(ICompositeViewEngine)))
.Returns(viewEngine.Object);
serviceProvider.Setup(p => p.GetService(typeof(ILogger <ViewResult>)))
.Returns(new Mock <ILogger <ViewResult> >().Object);
serviceProvider.Setup(s => s.GetService(typeof(IOptions <MvcViewOptions>)))
.Returns(() => {
var optionsAccessor = new Mock <IOptions <MvcViewOptions> >();
optionsAccessor.SetupGet(o => o.Value)
.Returns(new MvcViewOptions());
return(optionsAccessor.Object);
});
context.HttpContext.RequestServices = serviceProvider.Object;
var viewResult = new ViewResult
{
ViewName = viewName,
ViewData = new ViewDataDictionary(new EmptyModelMetadataProvider()),
TempData = Mock.Of <ITempDataDictionary>(),
};
// Act
await viewResult.ExecuteResultAsync(context);
// Assert
viewEngine.Verify();
}
/// <summary>
/// Make a new TelemetryListener, it is a TelemetrySource, which means the returned result can be used to
/// log notifications, but it also has a Subscribe method so notifications can be forwarded
/// arbitrarily. Thus its job is to forward things from the producer to all the listeners
/// (multi-casting). Generally you should not be making your own TelemetryListener but use the
/// TelemetryListener.Default, so that notifications are as 'public' as possible.
/// </summary>
public TelemetryListener()
{
// To avoid allocating an explicit lock object I lock the Default TelemetryListener. However there is a
// chicken and egg problem because I need to call this code to initialize Default.
var lockObj = DefaultListener;
if (lockObj == null)
lockObj = this;
// Insert myself into the list of all Listeners.
lock (lockObj)
{
m_next = s_allListeners;
s_allListeners = this;
}
}
public void DoubleDisposeOfListener()
{
var listener = new TelemetryListener("MyListener");
int completionCount = 0;
IDisposable subscription = listener.Subscribe(MakeObserver <KeyValuePair <string, object> >(_ => { }, () => completionCount++));
listener.Dispose();
listener.Dispose();
subscription.Dispose();
subscription.Dispose();
Assert.Equal(1, completionCount);
}
static void Main()
{
// This allows EventSources to listen to notifications.
// TODO this seems counterintuitive/unnecessary.
TelemetryEventSource.LogForDefaultNotificationHub.Touch();
// To set up a sink for notifications IObserver and hook up.
var consoleObserver = new ConsoleObserver("Default");
using (var subscription = TelemetryListener.Default.Subscribe(consoleObserver, consoleObserver.IsEnabled))
{
// This simulates an application that is creating Dispatcher/Notifier pairs for instantiable in-process contexts.
// The child hubs each cross-talk with the default hub, but do not cross-talk with each other
using (var island1 = new TelemetryListener("Island1"))
using (var island2 = new TelemetryListener("Island2"))
using (island1.Subscribe(new ConsoleObserver(island1.Name)))
using (island2.Subscribe(new ConsoleObserver(island2.Name)))
{
// Here we simulate what might happen in the class library where we don't use dependency injection.
// You can also get you iNotifier by asking IServiceProvider which might make one per tenant.
TelemetrySource defaultSource = TelemetrySource.Default;
TelemetrySource islandSource1 = island1;
TelemetrySource islandSource2 = island2;
// Normally this would be in code that was receiving the HttpRequestResponse
HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Get, "http://localhost/");
// Here we log for simple cases as show below we don't need to do the ShuldNotify, but we are
// showing the general case where there might be significant work setting up the payload.
if (defaultSource.IsEnabled("OutgoingHttpRequestReturns"))
{
// Here we are assuming we would like to log both to EventSource and direct subscribers to
// NotificationHub. Because of this the payload class contains both serializable fields (like
// ReqeustUri which we resolve to a string), as well as rich objects (like Message) that are
// stripped from EventSource serialization.
defaultSource.WriteTelemetry("OutgoingHttpRequestReturns", new { RequestUri = message.RequestUri.ToString(), Message = message });
}
islandSource1.WriteTelemetry("TalkingOnIsland", "Island One");
islandSource2.WriteTelemetry("TalkingOnIsland", "Island Two");
}
}
}
private IServiceCollection BuildHostingServices()
{
var services = new ServiceCollection();
// Import from manifest
var manifest = _services.GetService <IRuntimeServices>();
if (manifest != null)
{
foreach (var service in manifest.Services)
{
services.AddTransient(service, sp => _services.GetService(service));
}
}
services.AddInstance(_hostingEnvironment);
services.AddInstance(_loggerFactory);
services.AddTransient <IStartupLoader, StartupLoader>();
services.AddTransient <IServerLoader, ServerLoader>();
services.AddTransient <IApplicationBuilderFactory, ApplicationBuilderFactory>();
services.AddTransient <IHttpContextFactory, HttpContextFactory>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddLogging();
var telemetrySource = new TelemetryListener("Microsoft.AspNet");
services.AddInstance <TelemetrySource>(telemetrySource);
services.AddInstance <TelemetryListener>(telemetrySource);
// Conjure up a RequestServices
services.AddTransient <IStartupFilter, AutoRequestServicesStartupFilter>();
if (_configureServices != null)
{
_configureServices(services);
}
return(services);
}
public async Task ExceptionTelemetryAvailable()
{
TelemetryListener telemetryListener = null;
var server = TestServer.Create(app =>
{
telemetryListener = app.ApplicationServices.GetRequiredService <TelemetryListener>();
app.Run(context =>
{
throw new Exception("Test exception");
});
});
var listener = new TestTelemetryListener();
telemetryListener.SubscribeWithAdapter(listener);
await Assert.ThrowsAsync <Exception>(() => server.CreateClient().GetAsync("/path"));
Assert.NotNull(listener.BeginRequest?.HttpContext);
Assert.Null(listener.EndRequest?.HttpContext);
Assert.NotNull(listener.UnhandledException?.HttpContext);
Assert.NotNull(listener.UnhandledException?.Exception);
}
public async Task BeginEndTelemetryAvailable()
{
TelemetryListener telemetryListener = null;
var server = TestServer.Create(app =>
{
telemetryListener = app.ApplicationServices.GetRequiredService <TelemetryListener>();
app.Run(context =>
{
return(context.Response.WriteAsync("Hello World"));
});
});
var listener = new TestTelemetryListener();
telemetryListener.SubscribeWithAdapter(listener);
var result = await server.CreateClient().GetStringAsync("/path");
Assert.Equal("Hello World", result);
Assert.NotNull(listener.BeginRequest?.HttpContext);
Assert.NotNull(listener.EndRequest?.HttpContext);
Assert.Null(listener.UnhandledException);
}
public MainViewModel(VehicleService vs, VehicleListener vl, MapViewModel mp, TelemetryListener tl, CommandService cs, MissionService ms, RouteService rs, VehicleCommand vc)
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <ServiceTelemetryDTO, ClientTelemetry>();
});
logger.LogInfoMessage("Main window initialized");
MapViewModel = mp;
_vehicleService = vs;
_commandService = cs;
_missionService = ms;
_routeService = rs;
_vehicleCommand = vc;
try
{
ClientVehicle = new ClientVehicle();
ClientVehicle.Vehicle = vs.GetVehicleByName(Settings.Default.UgcsDroneProfileName);
ClientVehicle.Telemetry.Vehicle = ClientVehicle.Vehicle;
var subscription = new ObjectModificationSubscription();
subscription.ObjectId = ClientVehicle.Vehicle.Id;
subscription.ObjectType = "Vehicle";
_commandService.TryAcquireLock(ClientVehicle.Vehicle.Id);
tl.AddVehicleIdTolistener(ClientVehicle.Vehicle.Id, TelemetryCallBack);
vl.SubscribeVehicle(subscription, (e) =>
{
//Subscribe vehicle changes
});
MapViewModel.Init(ClientVehicle);
NotifyOfPropertyChange(() => MissionName);
NotifyOfPropertyChange(() => RouteName);
NotifyOfPropertyChange(() => VehicleName);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
Application.Current.Shutdown();
}
}
/// <summary>
/// Telemetry hubs are kept in a list
/// </summary>
public void Dispose()
{
// Remove myself from the list if all listeners.
lock (DefaultListener)
{
if (s_allListeners == this)
{
s_allListeners = s_allListeners.m_next;
}
else
{
var cur = s_allListeners;
while (cur != null)
{
if (cur.m_next == this)
{
cur.m_next = this.m_next;
break;
}
cur = cur.m_next;
}
}
}
}
/// <summary>
/// Telemetry hubs are kept in a list
/// </summary>
public void Dispose()
{
// Remove myself from the list if all listeners.
lock (DefaultListener)
{
if (s_allListeners == this)
s_allListeners = s_allListeners.m_next;
else
{
var cur = s_allListeners;
while (cur != null)
{
if (cur.m_next == this)
{
cur.m_next = this.m_next;
break;
}
cur = cur.m_next;
}
}
}
}
public void FirstTest()
{
using (var listener = new TelemetryListener(new TelemetryListenerSettings())) {
Thread.Sleep(1000);
}
}
private RouteContext CreateRouteContext(
ActionDescriptor actionDescriptor = null,
IActionSelector actionSelector = null,
IActionInvokerFactory invokerFactory = null,
ILoggerFactory loggerFactory = null,
IOptions <MvcOptions> optionsAccessor = null,
object telemetryListener = null)
{
if (actionDescriptor == null)
{
var mockAction = new Mock <ActionDescriptor>();
actionDescriptor = mockAction.Object;
}
if (actionSelector == null)
{
var mockActionSelector = new Mock <IActionSelector>();
mockActionSelector.Setup(a => a.SelectAsync(It.IsAny <RouteContext>()))
.Returns(Task.FromResult(actionDescriptor));
actionSelector = mockActionSelector.Object;
}
if (invokerFactory == null)
{
var mockInvoker = new Mock <IActionInvoker>();
mockInvoker.Setup(i => i.InvokeAsync())
.Returns(Task.FromResult(true));
var mockInvokerFactory = new Mock <IActionInvokerFactory>();
mockInvokerFactory.Setup(f => f.CreateInvoker(It.IsAny <ActionContext>()))
.Returns(mockInvoker.Object);
invokerFactory = mockInvokerFactory.Object;
}
if (loggerFactory == null)
{
loggerFactory = NullLoggerFactory.Instance;
}
if (optionsAccessor == null)
{
optionsAccessor = new TestOptionsManager <MvcOptions>();
}
var telemetry = new TelemetryListener("Microsoft.AspNet");
if (telemetryListener != null)
{
telemetry.SubscribeWithAdapter(telemetryListener);
}
var httpContext = new Mock <HttpContext>();
httpContext.Setup(h => h.RequestServices.GetService(typeof(IActionContextAccessor)))
.Returns(new ActionContextAccessor());
httpContext.Setup(h => h.RequestServices.GetService(typeof(IActionSelector)))
.Returns(actionSelector);
httpContext.Setup(h => h.RequestServices.GetService(typeof(IActionInvokerFactory)))
.Returns(invokerFactory);
httpContext.Setup(h => h.RequestServices.GetService(typeof(ILoggerFactory)))
.Returns(loggerFactory);
httpContext.Setup(h => h.RequestServices.GetService(typeof(MvcMarkerService)))
.Returns(new MvcMarkerService());
httpContext.Setup(h => h.RequestServices.GetService(typeof(IOptions <MvcOptions>)))
.Returns(optionsAccessor);
httpContext.Setup(h => h.RequestServices.GetService(typeof(TelemetrySource)))
.Returns(telemetry);
return(new RouteContext(httpContext.Object));
}
