public void Dispose_Disposes()
        {
            var mockTelemetryClientFactory = new Mock <ITelemetryClientFactory>(MockBehavior.Strict);

            mockTelemetryClientFactory.Setup(p => p.Create())
            .Returns <TelemetryClient>(null);
            mockTelemetryClientFactory.Setup(p => p.Dispose());

            var provider = new ApplicationInsightsLoggerProvider(null, mockTelemetryClientFactory.Object);

            provider.Dispose();
            provider.Dispose();

            // Ensure the second call is a no-op
            mockTelemetryClientFactory.Verify(p => p.Dispose(), Times.Once);
        }
示例#2
0
        public void Setup()
        {
            _configuration = TelemetryConfiguration.CreateDefault();
            _configuration.InstrumentationKey = "";
            _configuration.TelemetryInitializers.Add(new HttpDependenciesParsingTelemetryInitializer());

            _telemetryClient = new TelemetryClient(_configuration);

            _module.Initialize(_configuration);

            var loggerOptions = new ApplicationInsightsLoggerOptions();

            var applicationInsightsLoggerProvider = new ApplicationInsightsLoggerProvider(Options.Create(_configuration),
                                                                                          Options.Create(loggerOptions));

            ILoggerFactory factory = new LoggerFactory();

            factory.AddProvider(applicationInsightsLoggerProvider);

            LogContext.ConfigureCurrentLogContext(factory);
        }
        public static IHostBuilder CreateHostBuilder(string[] args)
        {
            return(Host.CreateDefaultBuilder(args)
                   .UseWindowsService()
                   .ConfigureAppConfiguration(cfg =>
            {
                cfg.SetBasePath(AppDomain.CurrentDomain.BaseDirectory);
            })
                   .ConfigureLogging((context, builder) =>
            {
                builder.AddConsole();
                builder.SetMinimumLevel(LogLevel.Trace);
            })
                   .ConfigureServices((hostContext, services) =>
            {
                var hostConfig = hostContext.Configuration;
                var module = new DependencyTrackingTelemetryModule();
                module.IncludeDiagnosticSourceActivities.Add("MassTransit");

                TelemetryConfiguration configuration = TelemetryConfiguration.CreateDefault();
                configuration.InstrumentationKey = "<your instrumentation key>";
                configuration.TelemetryInitializers.Add(new HttpDependenciesParsingTelemetryInitializer());

                module.Initialize(configuration);

                var loggerOptions = new ApplicationInsightsLoggerOptions();
                var applicationInsightsLoggerProvider = new ApplicationInsightsLoggerProvider(Options.Create(configuration),
                                                                                              Options.Create(loggerOptions));
                ILoggerFactory factory = new LoggerFactory();
                factory.AddProvider(applicationInsightsLoggerProvider);
                LogContext.ConfigureCurrentLogContext(factory);

                services.AddMassTransit(x =>
                {
                    x.AddConsumersFromNamespaceContaining <SubmitOrderConsumer>();
                    x.AddBus(context => Bus.Factory.CreateUsingAzureServiceBus(
                                 configurator =>
                    {
                        var host =
                            configurator.Host(hostConfig["AzureServiceBusConnectionString"],
                                              h => { });

                        configurator.ReceiveEndpoint("submit-order", e =>
                        {
                            e.Consumer <SubmitOrderConsumer>();
                        });

                        configurator.ReceiveEndpoint("order-observer", e =>
                        {
                            e.Consumer <OrderSubmittedConsumer>();
                        });

                        configurator.ReceiveEndpoint("order-state", e =>
                        {
                            var machine = new OrderStateMachine();
                            var repository = new InMemorySagaRepository <OrderState>();

                            e.StateMachineSaga(machine, repository);

                            EndpointConvention.Map <OrderProcessed>(e.InputAddress);
                        });

                        configurator.ReceiveEndpoint("execute-process-order", e =>
                        {
                            e.ExecuteActivityHost <ProcessOrderActivity, ProcessOrderArguments>();

                            EndpointConvention.Map <ProcessOrderArguments>(e.InputAddress);
                        });
                    }));
                });

                services.AddHostedService <WindowsService>();
            }));
        }