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)); }