示例#1
0
        public ClusterConfiguration GetClusterConfiguration()
        {
            var config = new ClusterConfiguration();

            var orleansConfig = new FabricConfigProvider <OrleansConfig>("OrleansConfig").Config;

            // Configure logging and metrics collection.
            //config.Defaults.StartupTypeName = typeof(SiloServiceLocator).AssemblyQualifiedName;
            config.Defaults.TraceFileName              = null;
            config.Defaults.TraceFilePattern           = null;
            config.Defaults.StatisticsCollectionLevel  = StatisticsLevel.Info;
            config.Defaults.StatisticsLogWriteInterval = TimeSpan.FromSeconds(10);
            config.Defaults.TurnWarningLengthThreshold = TimeSpan.FromSeconds(15);
            config.Defaults.TraceToConsole             = true;
            config.Defaults.DefaultTraceLevel          = Severity.Info;

            // Configure providers
            //config.Globals.RegisterStorageProvider<AzureTableStorage>(
            //    "Default",
            //    new Dictionary<string, string>
            //    {
            //        { "DataConnectionString", "DefaultEndpointsProtocol=https;AccountName=actorchatstorage;AccountKey=1hCY/Ak2TFrqE61cMhbPU5rkv9PuDfX7QQFU4tXCSc2AO78hLdm6u3PrGrZbUzOj7OkIZ93YKbU81VSVnBMbPg==" },
            //        { "UseJsonFormat", true.ToString(CultureInfo.InvariantCulture) }
            //    });
            config.Globals.DataConnectionString = orleansConfig.DataConnectionString;
            config.Globals.ReminderServiceType  = GlobalConfiguration.ReminderServiceProviderType.AzureTable;
            config.Globals.LivenessType         = GlobalConfiguration.LivenessProviderType.AzureTable;

            //config.Globals.ExpectedClusterSize = nodeList.Count; // An overestimate is tolerable.
            config.Globals.ResponseTimeout      = TimeSpan.FromSeconds(30);
            config.Defaults.PropagateActivityId = true;

            return(config);
        }
        async protected override Task RunAsync(CancellationToken cancellationToken)
        {
            var esLogsConfig = new FabricConfigProvider<ElasticSearchOutputConfig>("ElasticSearchLogs").Config;
            var esMetricsConfig = new FabricConfigProvider<ElasticSearchOutputConfig>("ElasticSearchMetrics").Config;

            var logger = new LoggerConfiguration()
                .ConfigureMOUSETypesDestructure()
                .MinimumLevel.Warning()
                .Enrich.With(new AzureServiceFabricSerilogEnricher(Context))
                .Enrich.With<ExceptionEnricher>()
                .WriteTo.Elasticsearch(
                    new ElasticsearchSinkOptions(new Uri(esLogsConfig.ElasticSearchUri))
                    {
                        IndexFormat = $"{esLogsConfig.ElasticSearchIndexName}-{{0:yyyy.MM.dd}}"
                    })
                .CreateLogger();
            Log.Logger = logger;


            Metric.Config.WithAllCounters();
            //Metric.PerformanceCounter("Actor calls waiting for actor lock", "Service Fabric Actor", "# of actor calls waiting for actor lock", "*", Unit.Items);
            //Metric.PerformanceCounter("Actor outstanding requests", "Service Fabric Actor", "# of outstanding requests", "*", Unit.Items);
            //Metric.PerformanceCounter("Actor Average milliseconds actor lock held", "Service Fabric Actor", "Average milliseconds actor lock held", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds for request deserialization", "Service Fabric Actor", "Average milliseconds for request deserialization", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds for response serialization", "Service Fabric Actor", "Average milliseconds for response serialization", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds per load state operation", "Service Fabric Actor", "Average milliseconds per load state operation", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds per lock wait", "Service Fabric Actor", "Average milliseconds per lock wait", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds per request", "Service Fabric Actor", "Average milliseconds per request", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds per save state operation", "Service Fabric Actor", "Average milliseconds per save state operation", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average OnActivateAsync milliseconds", "Service Fabric Actor", "Average OnActivateAsync milliseconds", "*", Unit.Custom("ms"));

            //Metric.PerformanceCounter("Actor Method Average milliseconds per invocation", "Service Fabric Actor Method", "Average milliseconds per invocation", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Method Exceptions thrown/Sec", "Service Fabric Actor Method", "Exceptions thrown/Sec", "*", Unit.Custom("rate/sec"));
            //Metric.PerformanceCounter("Actor Method Invocations/Sec", "Service Fabric Actor Method", "Invocations/Sec", "*", Unit.Custom("rate/sec"));


            var metricsSubscription = new TelemetryPipe()
                .CollectMetricsNet(5, ServiceFabricHelpers.GetEnvironmentProperties(Context), true)
                .SendToElasticSearch(esMetricsConfig)
                .Start();

            var logsSubscription = new TelemetryPipe()
                .CollectEventSourceEvents(new[]
                    {
                        //new ETWProvider("Microsoft-ServiceFabric-Services"),
                        //new ETWProvider("Microsoft-ServiceFabric-Actors"),
                        new ETWProvider("SFActorsPerfTest-SFTestActor")
                    }, ServiceFabricHelpers.GetEnvironmentProperties(Context))
                .SendToElasticSearch(esLogsConfig)
                .Start();


            using (logsSubscription)
            using (metricsSubscription)
            {
                await base.RunAsync(cancellationToken);

                await Task.Delay(Timeout.Infinite, cancellationToken);
            }
        }
示例#3
0
        public OrleansTestActorService(StatelessServiceContext context)
            : base(context)
        {
            var esLogsConfig    = new FabricConfigProvider <ElasticSearchOutputConfig>("ElasticSearchLogs").Config;
            var esMetricsConfig = new FabricConfigProvider <ElasticSearchOutputConfig>("ElasticSearchMetrics").Config;

            var logger = new LoggerConfiguration()
                         .MinimumLevel.Verbose()
                         .Enrich.With(new AzureServiceFabricSerilogEnricher(context))
                         .Enrich.With <ExceptionEnricher>()
                         .Enrich.With <ActivityIdSerilogEnricher>()
                         .WriteTo.Elasticsearch(
                new ElasticsearchSinkOptions(new Uri(esLogsConfig.ElasticSearchUri))
            {
                IndexFormat = $"{esLogsConfig.ElasticSearchIndexName}-{{0:yyyy.MM.dd}}"
            })
                         .CreateLogger();

            Log.Logger = logger;


            //Metric.Config.WithAllCounters();

            _disposable = new TelemetryPipe()
                          .CollectMetricsNet(10, ServiceFabricHelpers.GetEnvironmentProperties(context), true)
                          .SendToElasticSearch(esMetricsConfig)
                          .Start();

            TraceLogger.BulkMessageInterval = TimeSpan.FromSeconds(10);
            Logger.TelemetryConsumers.Add(new SerilogTelemetryConsumer());
            Logger.TelemetryConsumers.Add(new MetricNetTelemetryConsumer());
        }
        public ClusterConfiguration GetClusterConfiguration()
        {
            var config = new ClusterConfiguration();

            var orleansConfig = new FabricConfigProvider<OrleansConfig>("OrleansConfig").Config;

            // Configure logging and metrics collection.
            //config.Defaults.StartupTypeName = typeof(SiloServiceLocator).AssemblyQualifiedName;
            config.Defaults.TraceFileName = null;
            config.Defaults.TraceFilePattern = null;
            config.Defaults.StatisticsCollectionLevel = StatisticsLevel.Info;
            config.Defaults.StatisticsLogWriteInterval = TimeSpan.FromSeconds(10);
            config.Defaults.TurnWarningLengthThreshold = TimeSpan.FromSeconds(15);
            config.Defaults.TraceToConsole = true;
            config.Defaults.DefaultTraceLevel = Severity.Info;

            // Configure providers
            //config.Globals.RegisterStorageProvider<AzureTableStorage>(
            //    "Default",
            //    new Dictionary<string, string>
            //    {
            //        { "DataConnectionString", "DefaultEndpointsProtocol=https;AccountName=actorchatstorage;AccountKey=1hCY/Ak2TFrqE61cMhbPU5rkv9PuDfX7QQFU4tXCSc2AO78hLdm6u3PrGrZbUzOj7OkIZ93YKbU81VSVnBMbPg==" },
            //        { "UseJsonFormat", true.ToString(CultureInfo.InvariantCulture) }
            //    });
            config.Globals.DataConnectionString = orleansConfig.DataConnectionString;
            config.Globals.ReminderServiceType = GlobalConfiguration.ReminderServiceProviderType.AzureTable;
            config.Globals.LivenessType = GlobalConfiguration.LivenessProviderType.AzureTable;

            //config.Globals.ExpectedClusterSize = nodeList.Count; // An overestimate is tolerable.
            config.Globals.ResponseTimeout = TimeSpan.FromSeconds(30);
	        config.Defaults.PropagateActivityId = true;
			
            return config;
        }
	    public OrleansTestActorService(StatelessServiceContext context)
		    : base(context)
	    {
		    var esLogsConfig = new FabricConfigProvider<ElasticSearchOutputConfig>("ElasticSearchLogs").Config;
			var esMetricsConfig = new FabricConfigProvider<ElasticSearchOutputConfig>("ElasticSearchMetrics").Config;

			var logger = new LoggerConfiguration()
				.MinimumLevel.Verbose()
				.Enrich.With(new AzureServiceFabricSerilogEnricher(context))
				.Enrich.With<ExceptionEnricher>()
				.Enrich.With<ActivityIdSerilogEnricher>()
				.WriteTo.Elasticsearch(
					new ElasticsearchSinkOptions(new Uri(esLogsConfig.ElasticSearchUri))
					{
						IndexFormat = $"{esLogsConfig.ElasticSearchIndexName}-{{0:yyyy.MM.dd}}"
					})
				.CreateLogger();
			Log.Logger = logger;

			
			//Metric.Config.WithAllCounters();

			_disposable = new TelemetryPipe()
				.CollectMetricsNet(10, ServiceFabricHelpers.GetEnvironmentProperties(context), true)
				.SendToElasticSearch(esMetricsConfig)
				.Start();

			TraceLogger.BulkMessageInterval = TimeSpan.FromSeconds(10);
			Logger.TelemetryConsumers.Add(new SerilogTelemetryConsumer());
			Logger.TelemetryConsumers.Add(new MetricNetTelemetryConsumer());
		}
        public GatewayService(StatelessServiceContext context)
            : base(context)
        {
            WinApi.TimeBeginPeriod(1); //improve sleep precision for polling type transports

            float timeoutDebugMultiplier = 1;
            var   builder = new ContainerBuilder();

            var esLogsConfig    = new FabricConfigProvider <ElasticSearchOutputConfig>("ElasticSearchLogs").Config;
            var esMetricsConfig = new FabricConfigProvider <ElasticSearchOutputConfig>("ElasticSearchMetrics").Config;

            var logger = new LoggerConfiguration()
                         .ConfigureMOUSETypesDestructure()
                         .MinimumLevel.Error()
                         .Enrich.With(new AzureServiceFabricSerilogEnricher(context))
                         .Enrich.With <ExceptionEnricher>()
                         .Enrich.With <ActivityIdSerilogEnricher>()
                         .WriteTo.Elasticsearch(
                new ElasticsearchSinkOptions(new Uri(esLogsConfig.ElasticSearchUri))
            {
                IndexFormat = $"{esLogsConfig.ElasticSearchIndexName}-{{0:yyyy.MM.dd}}"
            })
                         .CreateLogger();

            Log.Logger = logger;

            builder.RegisterInstance(logger).As <ILogger>();
            builder.RegisterType <SerilogCoreEvents>().As <ICoreEvents>();
            builder.RegisterType <SerilogActorCoreEvents>().As <IActorCoreEvents>();
            builder.RegisterType <SerilogLidgrenEvents>().As <ILidgrenEvents>();

            Metric.Config.WithAllCounters();

            _metricsSubscription = new TelemetryPipe()
                                   .CollectMetricsNet(5, ServiceFabricHelpers.GetEnvironmentProperties(context), true)
                                   .SendToElasticSearch(esMetricsConfig)
                                   .Start();

            builder.Register(
                c => new ProtobufMessageSerializer(typeof(Message).Assembly, typeof(TestStateless).Assembly))
            .As <IMessageSerializer>();

            var publicEndpoint  = FabricRuntime.GetActivationContext().GetEndpoint("Public");
            var public2Endpoint = FabricRuntime.GetActivationContext().GetEndpoint("Public2");
            var public3Endpoint = FabricRuntime.GetActivationContext().GetEndpoint("Public3");
            var nodeIP          = Dns.GetHostAddresses(FabricRuntime.GetNodeContext().IPAddressOrFQDN).First(x => x.AddressFamily == AddressFamily.InterNetwork);

            var publicNetConfig = new NetPeerConfiguration("PublicNet")
            {
                LocalAddress              = nodeIP,
                MaximumConnections        = 10000,
                AcceptIncomingConnections = true,
                Port = publicEndpoint.Port,
                ConnectionTimeout = 10 * timeoutDebugMultiplier
            };
            var public2NetConfig = new NetPeerConfiguration("PublicNet")
            {
                LocalAddress              = nodeIP,
                MaximumConnections        = 10000,
                AcceptIncomingConnections = true,
                Port = public2Endpoint.Port,
                ConnectionTimeout = 10 * timeoutDebugMultiplier
            };

            var public3NetConfig = new NetPeerConfiguration("PublicNet")
            {
                LocalAddress              = nodeIP,
                MaximumConnections        = 10000,
                AcceptIncomingConnections = true,
                Port = public3Endpoint.Port,
                ConnectionTimeout = 10 * timeoutDebugMultiplier
            };

            var testActorsNetConfig = new NetPeerConfiguration("TestActors")
            {
                LocalAddress = nodeIP,
                AcceptIncomingConnections = false,
                Port = 0,
                ConnectionTimeout = 10 * timeoutDebugMultiplier
            };

            builder.RegisterType <WcfBufferPool>().As <IBufferPool>();

            builder.Register(c =>
            {
                var messageSerialer = c.Resolve <IMessageSerializer>();
                var coreLogger      = c.Resolve <ICoreEvents>();
                var nedNodeConfig   = c.Resolve <INetNodeConfig>();
                var bufferPool      = c.Resolve <IBufferPool>();

                return(new NetNode <SFActorsBackendClientNetChannel>("PublicNet",
                                                                     new LidgrenNetProvider(publicNetConfig, c.Resolve <ILidgrenEvents>()),
                                                                     coreLogger, messageSerialer,
                                                                     (node, transport) => new SFActorsBackendClientNetChannel(node, transport, messageSerialer, coreLogger, nedNodeConfig, bufferPool),
                                                                     nedNodeConfig));
            })
            .As <INetNode>()
            .SingleInstance();

            builder.Register(c =>
            {
                var actorSystem     = c.Resolve <IActorSystem <ITestActor> >();
                var messageSerialer = c.Resolve <IMessageSerializer>();
                var coreLogger      = c.Resolve <ICoreEvents>();
                var netNodeConfig   = c.Resolve <INetNodeConfig>();
                var bufferPool      = c.Resolve <IBufferPool>();

                return(new NetNode <MouseActorsBackendClientNetChannel>("PublicNet2",
                                                                        new LidgrenNetProvider(public2NetConfig, c.Resolve <ILidgrenEvents>()),
                                                                        coreLogger, messageSerialer,
                                                                        (node, transport) => new MouseActorsBackendClientNetChannel(actorSystem, node, transport, messageSerialer, coreLogger, netNodeConfig, bufferPool),
                                                                        netNodeConfig));
            })
            .As <INetNode>()
            .SingleInstance();

            builder.Register(c =>
            {
                var messageSerialer = c.Resolve <IMessageSerializer>();
                var coreLogger      = c.Resolve <ICoreEvents>();
                var netNodeConfig   = c.Resolve <INetNodeConfig>();
                var bufferPool      = c.Resolve <IBufferPool>();

                return(new NetNode <OrleansBackendClientNetChannel>("PublicNet3",
                                                                    new LidgrenNetProvider(public3NetConfig, c.Resolve <ILidgrenEvents>()),
                                                                    coreLogger, messageSerialer,
                                                                    (node, transport) => new OrleansBackendClientNetChannel(node, transport, messageSerialer, coreLogger, netNodeConfig, bufferPool),
                                                                    netNodeConfig));
            })
            .As <INetNode>()
            .SingleInstance();

            builder.Register(c =>
                             new ServiceFabricActorSystemNetNode <ITestActor>("TestActors", new Uri("fabric:/MouseTestActor.Deploy/MouseTestActor"),
                                                                              new LidgrenNetProvider(testActorsNetConfig, c.Resolve <ILidgrenEvents>()),
                                                                              c.Resolve <IActorCoreEvents>(), c.Resolve <ICoreEvents>(), c.Resolve <IMessageSerializer>(), c.Resolve <INetNodeConfig>(), c.Resolve <IBufferPool>()))
            .As <INetNode>()
            .As <IActorSystem <ITestActor> >()
            .SingleInstance();

            builder.Register(c => new NetNodeConfig()
            {
                SendTimeoutSec    = (int)(10.0 * timeoutDebugMultiplier),
                ConnectTimeoutSec = (int)(10 * timeoutDebugMultiplier)
            }).As <INetNodeConfig>();

            var container = builder.Build();

            _netNodes = container.Resolve <IEnumerable <INetNode> >();

            var config = new ClientConfiguration
            {
                //DataConnectionString = "DefaultEndpointsProtocol=https;AccountName=actorchatstorage;AccountKey=1hCY/Ak2TFrqE61cMhbPU5rkv9PuDfX7QQFU4tXCSc2AO78hLdm6u3PrGrZbUzOj7OkIZ93YKbU81VSVnBMbPg==",
                DataConnectionString       = "UseDevelopmentStorage=true",
                PropagateActivityId        = true,
                DefaultTraceLevel          = Severity.Info,
                GatewayProvider            = ClientConfiguration.GatewayProviderType.AzureTable,
                TraceToConsole             = true,
                StatisticsCollectionLevel  = StatisticsLevel.Critical,
                StatisticsLogWriteInterval = TimeSpan.FromDays(6),
                TraceFileName    = null,
                TraceFilePattern = null,
                ResponseTimeout  = TimeSpan.FromSeconds(90),
                StatisticsMetricsTableWriteInterval = TimeSpan.FromDays(6),
                StatisticsPerfCountersWriteInterval = TimeSpan.FromDays(6),
            };

            OrleansFabricClient.Initialize(new Uri("fabric:/OrleansTest/OrleansTestActor"), config);
        }
        public MouseTestActorService(StatefulServiceContext context)
            : base(context)
        {
            WinApi.TimeBeginPeriod(1); //improve sleep precision for polling type transports

            float timeoutDebugMultiplier = 1;
            var   builder = new ContainerBuilder();

            var esLogsConfig    = new FabricConfigProvider <ElasticSearchOutputConfig>("ElasticSearchLogs").Config;
            var esMetricsConfig = new FabricConfigProvider <ElasticSearchOutputConfig>("ElasticSearchMetrics").Config;

            var logger = new LoggerConfiguration()
                         .ConfigureMOUSETypesDestructure()
                         .MinimumLevel.Error()
                         .Enrich.With(new AzureServiceFabricSerilogEnricher(context))
                         .Enrich.With <ExceptionEnricher>()
                         .Enrich.With <ActivityIdSerilogEnricher>()
                         .WriteTo.Elasticsearch(
                new ElasticsearchSinkOptions(new Uri(esLogsConfig.ElasticSearchUri))
            {
                IndexFormat = $"{esLogsConfig.ElasticSearchIndexName}-{{0:yyyy.MM.dd}}"
            })
                         .CreateLogger();

            Log.Logger = logger;

            builder.RegisterInstance(logger).As <ILogger>();
            builder.RegisterType <SerilogCoreEvents>().As <ICoreEvents>();
            builder.RegisterType <SerilogActorCoreEvents>().As <IActorCoreEvents>();
            builder.RegisterType <SerilogLidgrenEvents>().As <ILidgrenEvents>();

            Metric.Config.WithAllCounters();

            _metricsSubscription = new TelemetryPipe()
                                   .CollectMetricsNet(5, ServiceFabricHelpers.GetEnvironmentProperties(context), true)
                                   .SendToElasticSearch(esMetricsConfig)
                                   .Start();

            builder.Register(c => new ProtobufMessageSerializer(typeof(Message).Assembly, typeof(TestStateless).Assembly)).As <IMessageSerializer>();

            var roomActorsEndpoint = FabricRuntime.GetActivationContext().GetEndpoint("TestActors");

            var nodeIP = Dns.GetHostAddresses(FabricRuntime.GetNodeContext().IPAddressOrFQDN).First(x => x.AddressFamily == AddressFamily.InterNetwork);

            var roomActorsNetConfig = new NetPeerConfiguration("TestActors")
            {
                LocalAddress              = nodeIP,
                MaximumConnections        = 10000,
                AcceptIncomingConnections = true,
                Port = roomActorsEndpoint.Port,
                ConnectionTimeout = 10 * timeoutDebugMultiplier
            };


            builder.RegisterType <WcfBufferPool>().As <IBufferPool>();

            builder.Register(c => new NetNodeConfig()
            {
                SendTimeoutSec    = (int)(10.0 * timeoutDebugMultiplier),
                ConnectTimeoutSec = (int)(10 * timeoutDebugMultiplier)
            }).As <INetNodeConfig>();

            builder.Register(c => new TestActor(StateManager)).As <ITestActor>();
            builder.Register(c =>
                             new ServiceFabricActorSystemNetNode <ITestActor>("TestActors", Context.ServiceName,
                                                                              new LidgrenNetProvider(roomActorsNetConfig, c.Resolve <ILidgrenEvents>()),
                                                                              c.Resolve <IActorCoreEvents>(), c.Resolve <ICoreEvents>(), c.Resolve <IMessageSerializer>(), c.Resolve <INetNodeConfig>(), c.Resolve <IBufferPool>(),
                                                                              actorFactory: c.Resolve <Func <ITestActor> >()))
            .As <INetNode>()
            .SingleInstance();

            var container = builder.Build();


            _netNodes = container.Resolve <IEnumerable <INetNode> >();
        }
        public GatewayService(StatelessServiceContext context)
            : base(context)
        {
            WinApi.TimeBeginPeriod(1); //improve sleep precision for polling type transports

            float timeoutDebugMultiplier = 1;
            var builder = new ContainerBuilder();

            var esLogsConfig = new FabricConfigProvider<ElasticSearchOutputConfig>("ElasticSearchLogs").Config;
            var esMetricsConfig = new FabricConfigProvider<ElasticSearchOutputConfig>("ElasticSearchMetrics").Config;

            var logger = new LoggerConfiguration()
                .ConfigureMOUSETypesDestructure()
                .MinimumLevel.Error()
                .Enrich.With(new AzureServiceFabricSerilogEnricher(context))
                .Enrich.With<ExceptionEnricher>()
                .Enrich.With<ActivityIdSerilogEnricher>()
                .WriteTo.Elasticsearch(
                    new ElasticsearchSinkOptions(new Uri(esLogsConfig.ElasticSearchUri))
                    {
                        IndexFormat = $"{esLogsConfig.ElasticSearchIndexName}-{{0:yyyy.MM.dd}}"
                    })
                .CreateLogger();
            Log.Logger = logger;

            builder.RegisterInstance(logger).As<ILogger>();
            builder.RegisterType<SerilogCoreEvents>().As<ICoreEvents>();
            builder.RegisterType<SerilogActorCoreEvents>().As<IActorCoreEvents>();
            builder.RegisterType<SerilogLidgrenEvents>().As<ILidgrenEvents>();

            Metric.Config.WithAllCounters();

            _metricsSubscription = new TelemetryPipe()
                .CollectMetricsNet(5, ServiceFabricHelpers.GetEnvironmentProperties(context), true)
                .SendToElasticSearch(esMetricsConfig)
                .Start();

            builder.Register(
                c => new ProtobufMessageSerializer(typeof(Message).Assembly, typeof(TestStateless).Assembly))
                .As<IMessageSerializer>();

            var publicEndpoint = FabricRuntime.GetActivationContext().GetEndpoint("Public");
            var public2Endpoint = FabricRuntime.GetActivationContext().GetEndpoint("Public2");
            var public3Endpoint = FabricRuntime.GetActivationContext().GetEndpoint("Public3");
            var nodeIP = Dns.GetHostAddresses(FabricRuntime.GetNodeContext().IPAddressOrFQDN).First(x => x.AddressFamily == AddressFamily.InterNetwork);

            var publicNetConfig = new NetPeerConfiguration("PublicNet")
            {
                LocalAddress = nodeIP,
                MaximumConnections = 10000,
                AcceptIncomingConnections = true,
                Port = publicEndpoint.Port,
                ConnectionTimeout = 10*timeoutDebugMultiplier
            };
            var public2NetConfig = new NetPeerConfiguration("PublicNet")
            {
                LocalAddress = nodeIP,
                MaximumConnections = 10000,
                AcceptIncomingConnections = true,
                Port = public2Endpoint.Port,
                ConnectionTimeout = 10 * timeoutDebugMultiplier
            };

            var public3NetConfig = new NetPeerConfiguration("PublicNet")
            {
                LocalAddress = nodeIP,
                MaximumConnections = 10000,
                AcceptIncomingConnections = true,
                Port = public3Endpoint.Port,
                ConnectionTimeout = 10 * timeoutDebugMultiplier
            };

            var testActorsNetConfig = new NetPeerConfiguration("TestActors")
            {
                LocalAddress = nodeIP,
                AcceptIncomingConnections = false,
                Port = 0,
                ConnectionTimeout = 10 * timeoutDebugMultiplier
            };

            builder.RegisterType<WcfBufferPool>().As<IBufferPool>();

            builder.Register(c =>
                {
                    var messageSerialer = c.Resolve<IMessageSerializer>();
                    var coreLogger = c.Resolve<ICoreEvents>();
                    var nedNodeConfig = c.Resolve<INetNodeConfig>();
                    var bufferPool = c.Resolve<IBufferPool>();

                    return new NetNode<SFActorsBackendClientNetChannel>("PublicNet",
                        new LidgrenNetProvider(publicNetConfig, c.Resolve<ILidgrenEvents>()),
                        coreLogger, messageSerialer,
                        (node, transport) => new SFActorsBackendClientNetChannel(node, transport, messageSerialer, coreLogger, nedNodeConfig, bufferPool),
                        nedNodeConfig);
                })
                .As<INetNode>()
                .SingleInstance();

            builder.Register(c =>
                {
                    var actorSystem = c.Resolve<IActorSystem<ITestActor>>();
                    var messageSerialer = c.Resolve<IMessageSerializer>();
                    var coreLogger = c.Resolve<ICoreEvents>();
                    var netNodeConfig = c.Resolve<INetNodeConfig>();
                    var bufferPool = c.Resolve<IBufferPool>();

                    return new NetNode<MouseActorsBackendClientNetChannel>("PublicNet2",
                        new LidgrenNetProvider(public2NetConfig, c.Resolve<ILidgrenEvents>()),
                        coreLogger, messageSerialer,
                        (node, transport) => new MouseActorsBackendClientNetChannel(actorSystem,  node, transport, messageSerialer, coreLogger, netNodeConfig, bufferPool),
                        netNodeConfig);
                })
                .As<INetNode>()
                .SingleInstance();

            builder.Register(c =>
            {
                var messageSerialer = c.Resolve<IMessageSerializer>();
                var coreLogger = c.Resolve<ICoreEvents>();
                var netNodeConfig = c.Resolve<INetNodeConfig>();
                var bufferPool = c.Resolve<IBufferPool>();

                return new NetNode<OrleansBackendClientNetChannel>("PublicNet3",
                    new LidgrenNetProvider(public3NetConfig, c.Resolve<ILidgrenEvents>()),
                    coreLogger, messageSerialer,
                    (node, transport) => new OrleansBackendClientNetChannel(node, transport, messageSerialer, coreLogger, netNodeConfig, bufferPool),
                    netNodeConfig);
            })
                .As<INetNode>()
                .SingleInstance();

            builder.Register(c =>
                    new ServiceFabricActorSystemNetNode<ITestActor>("TestActors", new Uri("fabric:/MouseTestActor.Deploy/MouseTestActor"),
                        new LidgrenNetProvider(testActorsNetConfig, c.Resolve<ILidgrenEvents>()),
                        c.Resolve<IActorCoreEvents>(), c.Resolve<ICoreEvents>(), c.Resolve<IMessageSerializer>(), c.Resolve<INetNodeConfig>(), c.Resolve<IBufferPool>()))
               .As<INetNode>()
               .As<IActorSystem<ITestActor>>()
               .SingleInstance();

            builder.Register(c => new NetNodeConfig()
            {
                SendTimeoutSec = (int) (10.0*timeoutDebugMultiplier),
                ConnectTimeoutSec = (int) (10*timeoutDebugMultiplier)
            }).As<INetNodeConfig>();

            var container = builder.Build();

            _netNodes = container.Resolve<IEnumerable<INetNode>>();

			var config = new ClientConfiguration
            {
                //DataConnectionString = "DefaultEndpointsProtocol=https;AccountName=actorchatstorage;AccountKey=1hCY/Ak2TFrqE61cMhbPU5rkv9PuDfX7QQFU4tXCSc2AO78hLdm6u3PrGrZbUzOj7OkIZ93YKbU81VSVnBMbPg==",
                DataConnectionString = "UseDevelopmentStorage=true",
                PropagateActivityId = true,
                DefaultTraceLevel = Severity.Info,
                GatewayProvider = ClientConfiguration.GatewayProviderType.AzureTable,
                TraceToConsole = true,
                StatisticsCollectionLevel = StatisticsLevel.Critical,
                StatisticsLogWriteInterval = TimeSpan.FromDays(6),
                TraceFileName = null,
                TraceFilePattern = null,
                ResponseTimeout = TimeSpan.FromSeconds(90),
                StatisticsMetricsTableWriteInterval = TimeSpan.FromDays(6),
                StatisticsPerfCountersWriteInterval = TimeSpan.FromDays(6),
            };
            OrleansFabricClient.Initialize(new Uri("fabric:/OrleansTest/OrleansTestActor"), config);
            
        }
        async protected override Task RunAsync(CancellationToken cancellationToken)
        {
            var esLogsConfig    = new FabricConfigProvider <ElasticSearchOutputConfig>("ElasticSearchLogs").Config;
            var esMetricsConfig = new FabricConfigProvider <ElasticSearchOutputConfig>("ElasticSearchMetrics").Config;

            var logger = new LoggerConfiguration()
                         .ConfigureMOUSETypesDestructure()
                         .MinimumLevel.Warning()
                         .Enrich.With(new AzureServiceFabricSerilogEnricher(Context))
                         .Enrich.With <ExceptionEnricher>()
                         .WriteTo.Elasticsearch(
                new ElasticsearchSinkOptions(new Uri(esLogsConfig.ElasticSearchUri))
            {
                IndexFormat = $"{esLogsConfig.ElasticSearchIndexName}-{{0:yyyy.MM.dd}}"
            })
                         .CreateLogger();

            Log.Logger = logger;


            Metric.Config.WithAllCounters();
            //Metric.PerformanceCounter("Actor calls waiting for actor lock", "Service Fabric Actor", "# of actor calls waiting for actor lock", "*", Unit.Items);
            //Metric.PerformanceCounter("Actor outstanding requests", "Service Fabric Actor", "# of outstanding requests", "*", Unit.Items);
            //Metric.PerformanceCounter("Actor Average milliseconds actor lock held", "Service Fabric Actor", "Average milliseconds actor lock held", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds for request deserialization", "Service Fabric Actor", "Average milliseconds for request deserialization", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds for response serialization", "Service Fabric Actor", "Average milliseconds for response serialization", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds per load state operation", "Service Fabric Actor", "Average milliseconds per load state operation", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds per lock wait", "Service Fabric Actor", "Average milliseconds per lock wait", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds per request", "Service Fabric Actor", "Average milliseconds per request", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average milliseconds per save state operation", "Service Fabric Actor", "Average milliseconds per save state operation", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Average OnActivateAsync milliseconds", "Service Fabric Actor", "Average OnActivateAsync milliseconds", "*", Unit.Custom("ms"));

            //Metric.PerformanceCounter("Actor Method Average milliseconds per invocation", "Service Fabric Actor Method", "Average milliseconds per invocation", "*", Unit.Custom("ms"));
            //Metric.PerformanceCounter("Actor Method Exceptions thrown/Sec", "Service Fabric Actor Method", "Exceptions thrown/Sec", "*", Unit.Custom("rate/sec"));
            //Metric.PerformanceCounter("Actor Method Invocations/Sec", "Service Fabric Actor Method", "Invocations/Sec", "*", Unit.Custom("rate/sec"));


            var metricsSubscription = new TelemetryPipe()
                                      .CollectMetricsNet(5, ServiceFabricHelpers.GetEnvironmentProperties(Context), true)
                                      .SendToElasticSearch(esMetricsConfig)
                                      .Start();

            var logsSubscription = new TelemetryPipe()
                                   .CollectEventSourceEvents(new[]
            {
                //new ETWProvider("Microsoft-ServiceFabric-Services"),
                //new ETWProvider("Microsoft-ServiceFabric-Actors"),
                new ETWProvider("SFActorsPerfTest-SFTestActor")
            }, ServiceFabricHelpers.GetEnvironmentProperties(Context))
                                   .SendToElasticSearch(esLogsConfig)
                                   .Start();


            using (logsSubscription)
                using (metricsSubscription)
                {
                    await base.RunAsync(cancellationToken);

                    await Task.Delay(Timeout.Infinite, cancellationToken);
                }
        }