static void TestRollingEventSequence(
            IEnumerable<LogEvent> events,
            int? retainedFiles,
            Action<IList<string>> verifyWritten)
        {
            var fileName = Some.String() + "-{Date}.txt";
            var folder = Some.TempFolderPath();
            var pathFormat = Path.Combine(folder, fileName);

            var log = new LoggerConfiguration()
                .WriteTo.RollingFile(pathFormat, retainedFileCountLimit: retainedFiles)
                .CreateLogger();

            var verified = new List<string>();

            try
            {
                foreach (var @event in events)
                {
                    Clock.SetTestDateTimeNow(@event.Timestamp.DateTime);
                    log.Write(@event);

                    var expected = pathFormat.Replace("{Date}", @event.Timestamp.ToString("yyyyMMdd"));
                    Assert.That(File.Exists(expected));

                    verified.Add(expected);
                }
            }
            finally
            {
                ((IDisposable)log).Dispose();
                verifyWritten(verified);
                Directory.Delete(folder, true);
            }
        }

        static void TestRollingEventSequence(params LogEvent[] events)
        {
            var fileName = Some.String() + "{0}.txt";
            var folder = Some.TempFolderPath();
            var pathFormat = Path.Combine(folder, fileName);

            var log = new LoggerConfiguration()
                .WriteTo.RollingFile(pathFormat)
                .CreateLogger();

            try
            {
                foreach (var @event in events)
                {
                    log.Write(@event);

                    var expected = string.Format(pathFormat, @event.Timestamp.ToString("yyyy-MM-dd"));
                    Assert.That(System.IO.File.Exists(expected));
                }
            }
            finally
            {
                ((IDisposable)log).Dispose();
                Directory.Delete(folder, true);
            }
        }

 internal LoggerSinkConfiguration(LoggerConfiguration loggerConfiguration, Action<ILogEventSink> addSink)
 {
     if (loggerConfiguration == null) throw new ArgumentNullException("loggerConfiguration");
     if (addSink == null) throw new ArgumentNullException("addSink");
     _loggerConfiguration = loggerConfiguration;
     _addSink = addSink;
 }

        public void UsingSuperLongLogMessageWorks()
        {
            var charcounts = new[]
            {
                10*1000,
                20*1000,
                30*1000,
                40*1000,
                70*1000
            };
            foreach (var charcount in charcounts)
            {
                var log = new LoggerConfiguration()
                    .WriteTo.EventLog("EventLogSinkTests")
                    .CreateLogger();

                var guid = Guid.NewGuid().ToString("D");
                log.Information("This is a super long message which might be trimmed. Guid is {Guid}.The following text has {charcount} chars: {LongText}"
                    , guid
                    , charcount
                    , new string('x', charcount));

                Assert.IsTrue(EventLogMessageWithSpecificBodyExists(guid), "The message was not found in the eventlog. Charcount was " + charcount);
            }
        }

        public void MoreNestedPropertiesOverrideLessNestedOnes()
        {
            LogEvent lastEvent = null;

            var log = new LoggerConfiguration()
                .Enrich.FromLogContext()
                .WriteTo.Sink(new DelegatingSink(e => lastEvent = e))
                .CreateLogger();

            using (LogContext.PushProperty("A", 1))
            {
                log.Write(Some.InformationEvent());
                Assert.AreEqual(1, lastEvent.Properties["A"].LiteralValue());

                using (LogContext.PushProperty("A", 2))
                {
                    log.Write(Some.InformationEvent());
                    Assert.AreEqual(2, lastEvent.Properties["A"].LiteralValue());
                }

                log.Write(Some.InformationEvent());
                Assert.AreEqual(1, lastEvent.Properties["A"].LiteralValue());
            }

            log.Write(Some.InformationEvent());
            Assert.IsFalse(lastEvent.Properties.ContainsKey("A"));
        }

 internal LoggerMinimumLevelConfiguration(LoggerConfiguration loggerConfiguration, Action<LogEventLevel> setMinimum)
 {
     if (loggerConfiguration == null) throw new ArgumentNullException("loggerConfiguration");
     if (setMinimum == null) throw new ArgumentNullException("setMinimum");
     _loggerConfiguration = loggerConfiguration;
     _setMinimum = setMinimum;
 }

        public void AttributesAreConsultedWhenDestructuring()
        {
            LogEvent evt = null;

            var log = new LoggerConfiguration()
                .Destructure.UsingAttributes()
                .WriteTo.Sink(new DelegatingSink(e => evt = e))
                .CreateLogger();

            var customized = new Customized
            {
                ImmutableScalar = new ImmutableScalar(),
                MutableScalar = new MutableScalar(),
                NotAScalar = new NotAScalar(),
                Ignored = "Hello, there",
                ScalarAnyway = new NotAScalar()
            };

            log.Information("Here is {@Customized}", customized);

            var sv = (StructureValue)evt.Properties["Customized"];
            var props = sv.Properties.ToDictionary(p => p.Name, p => p.Value);

            Assert.IsInstanceOf<ImmutableScalar>(props["ImmutableScalar"].LiteralValue());
            Assert.AreEqual(new MutableScalar().ToString(), props["MutableScalar"].LiteralValue());
            Assert.IsInstanceOf<StructureValue>(props["NotAScalar"]);
            Assert.IsFalse(props.ContainsKey("Ignored"));
            Assert.IsInstanceOf<NotAScalar>(props["ScalarAnyway"].LiteralValue());
        }

        public void LoggingLevelSwitchDynamicallyChangesLevel()
        {
            var events = new List<LogEvent>();
            var sink = new DelegatingSink(events.Add);

            var levelSwitch = new LoggingLevelSwitch(LogEventLevel.Information);

            var log = new LoggerConfiguration()
                .MinimumLevel.ControlledBy(levelSwitch)
                .WriteTo.Sink(sink)
                .CreateLogger()
                .ForContext<LoggerTests>();

            log.Debug("Suppressed");
            log.Information("Emitted");
            log.Warning("Emitted");

            // Change the level
            levelSwitch.MinimumLevel = LogEventLevel.Error;

            log.Warning("Suppressed");
            log.Error("Emitted");
            log.Fatal("Emitted");

            Assert.Equal(4, events.Count);
            Assert.True(events.All(evt => evt.RenderMessage() == "Emitted"));
        }

        public async Task ContextPropertiesCrossAsyncCalls()
        {
            LogEvent lastEvent = null;

            var log = new LoggerConfiguration()
                .Enrich.FromLogContext()
                .WriteTo.Sink(new DelegatingSink(e => lastEvent = e))
                .CreateLogger();

            using (LogContext.PushProperty("A", 1))
            {
                var pre = Thread.CurrentThread.ManagedThreadId;

                await Task.Delay(1000);

                var post = Thread.CurrentThread.ManagedThreadId;

                log.Write(Some.InformationEvent());
                Assert.AreEqual(1, lastEvent.Properties["A"].LiteralValue());

                // No problem if this happens occasionally.
                if (pre == post)
                    Assert.Inconclusive("The test was marshalled back to the same thread after awaiting");
            }
        }

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

        static void TestRollingEventSequence(IEnumerable<LogEvent> events, int? retainedFiles, Action<IList<string>> verifyWritten)
        {
            var fileName = Some.String() + "-{Date}.txt";
            var folder = Some.TempFolderPath();
            var pathFormat = Path.Combine(folder, fileName);

            var log = new LoggerConfiguration()
                .WriteTo.SizeRollingFile(pathFormat, retainedFileDurationLimit: TimeSpan.FromSeconds(180))
                .CreateLogger();

            var verified = new List<string>();

            try
            {
                foreach (var @event in events)
                {                    
                    log.Write(@event);

                    var expected = pathFormat.Replace("{Date}", DateTime.UtcNow.ToString("yyyyMMdd") + "_0001");                    
                    Assert.True(File.Exists(expected));

                    verified.Add(expected);
                }
            }
            finally
            {
                ((IDisposable)log).Dispose();
                verifyWritten(verified);
                Directory.Delete(folder, true);
            }
        }

        static void TestLoggingAndDelete(string path)
        {
            ILogger log = null;

            try
            {
                log = new LoggerConfiguration()
                    .WriteTo.File(path)
                    .CreateLogger();

                var message = Some.MessageTemplate();

                log.Write(new LogEvent(
                    DateTimeOffset.Now,
                    LogEventLevel.Information,
                    null,
                    message,
                    Enumerable.Empty<LogEventProperty>()));

                var refile = System.IO.File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                var content = new StreamReader(refile).ReadToEnd();
                refile.Dispose();

                Assert.That(content.Contains(message.Text));
            }
            finally
            {
                var disposable = (IDisposable) log;
                    if (disposable != null) disposable.Dispose();
                System.IO.File.Delete(path);
            }
        }

        public void CanUseCustomSettingDelimiterToConfigureSettings()
        {
            const string prefix1 = "|";
            const string prefix2 = "!";

            // Make sure we have the expected keys in the App.config
            Assert.AreEqual("Warning", ConfigurationManager.AppSettings["serilog|minimum-level"]);
            Assert.AreEqual("Error", ConfigurationManager.AppSettings["serilog!minimum-level"]);

            var log1 = new LoggerConfiguration()
               .WriteTo.Observers(o => { })
               .ReadFrom.AppSettings(null,prefix1)
               .CreateLogger();

            var log2 = new LoggerConfiguration()
                .WriteTo.Observers(o => { })
                .ReadFrom.AppSettings(null,prefix2)
                .CreateLogger();

            Assert.IsFalse(log1.IsEnabled(LogEventLevel.Information));
            Assert.IsTrue(log1.IsEnabled(LogEventLevel.Warning));

            Assert.IsFalse(log2.IsEnabled(LogEventLevel.Warning));
            Assert.IsTrue(log2.IsEnabled(LogEventLevel.Error));
        }

		public void WhenALoggerWritesToTheSinkItIsRetrievableFromTheTableWithProperties()
		{
			var storageAccount = CloudStorageAccount.DevelopmentStorageAccount;
			var tableClient = storageAccount.CreateCloudTableClient();
			var table = tableClient.GetTableReference("LogEventEntity");

			table.DeleteIfExists();

			var logger = new LoggerConfiguration()
				.WriteTo.AzureTableStorageWithProperties(storageAccount)
				.CreateLogger();

			var exception = new ArgumentException("Some exception");

			const string messageTemplate = "{Properties} should go in their {Numbered} {Space}";

			logger.Information(exception, messageTemplate, "Properties", 1234, ' ');

			var result = table.ExecuteQuery(new TableQuery().Take(1)).First();
			
			// Check the presence of same properties as in previous version
			Assert.AreEqual(messageTemplate, result.Properties["MessageTemplate"].StringValue);
			Assert.AreEqual("Information", result.Properties["Level"].StringValue);
			Assert.AreEqual("System.ArgumentException: Some exception", result.Properties["Exception"].StringValue);
			Assert.AreEqual("\"Properties\" should go in their 1234  ", result.Properties["RenderedMessage"].StringValue);

			// Check the presence of the new properties.
			Assert.AreEqual("Properties", result.Properties["Properties"].PropertyAsObject);
			Assert.AreEqual(1234, result.Properties["Numbered"].PropertyAsObject);
			Assert.AreEqual(" ", result.Properties["Space"].PropertyAsObject);
		}

 /// <summary>
 /// Write log events to a sub-logger, where further processing may occur. Events through
 /// the sub-logger will be constrained by filters and enriched by enrichers that are
 /// active in the parent. A sub-logger cannot be used to log at a more verbose level, but
 /// a less verbose level is possible.
 /// </summary>
 /// <param name="configureLogger">An action that configures the sub-logger.</param>
 /// <returns>Configuration object allowing method chaining.</returns>
 public LoggerConfiguration Logger(
     Action<LoggerConfiguration> configureLogger)
 {
     if (configureLogger == null) throw new ArgumentNullException("configureLogger");
     var lc = new LoggerConfiguration();
     configureLogger(lc);
     return Sink(new CopyingSink((ILogEventSink)lc.CreateLogger()));
 }

        public void LoggerTest()
        {
            var logger = new LoggerConfiguration()
                .MinimumLevel.Debug()
                .WriteTo.WebRequest(new Uri(Url))
                .CreateLogger();

            logger.Information("Hello World");
        }

 internal LoggerFilterConfiguration(
     LoggerConfiguration loggerConfiguration,
     Action<ILogEventFilter> addFilter)
 {
     if (loggerConfiguration == null) throw new ArgumentNullException("loggerConfiguration");
     if (addFilter == null) throw new ArgumentNullException("addFilter");
     _loggerConfiguration = loggerConfiguration;
     _addFilter = addFilter;
 }

        public void ShouldCreateInstanceOfLogger()
        {
            var loggerConfiguration = new LoggerConfiguration();

            loggerConfiguration.WriteTo.SizeRollingFile(new CompactJsonFormatter(), "c:\\logs\\Log-{{Date}}.json", retainedFileDurationLimit: TimeSpan.FromDays(3));

            var logger = loggerConfiguration.CreateLogger();

            Assert.IsNotNull(logger);
        }

        public static LogEvent GetLogEvent(Action<ILogger> writeAction)
        {
            LogEvent result = null;
            var l = new LoggerConfiguration()
                .WriteTo.Sink(new DelegatingSink(le => result = le))
                .CreateLogger();

            writeAction(l);
            return result;
        }

 internal LoggerMinimumLevelConfiguration(LoggerConfiguration loggerConfiguration, Action<LogEventLevel> setMinimum, 
                                          Action<LoggingLevelSwitch> setLevelSwitch, Action<string, LoggingLevelSwitch> addOverride)
 {
     if (loggerConfiguration == null) throw new ArgumentNullException(nameof(loggerConfiguration));
     if (setMinimum == null) throw new ArgumentNullException(nameof(setMinimum));
     if (addOverride == null) throw new ArgumentNullException(nameof(addOverride));
     _loggerConfiguration = loggerConfiguration;
     _setMinimum = setMinimum;
     _setLevelSwitch = setLevelSwitch;
     _addOverride = addOverride;
 }