public void BuildMethodHappyPath2()
{
var services = new ServiceCollection();
var logProcessor = new Mock <ILogProcessor>().Object;
services.AddSingleton(logProcessor);
var builder = new LoggerBuilder(services, Logger.DefaultName, options =>
{
options.Level = LogLevel.Info;
options.ReloadOnChange = true;
});
var logProvider = new Mock <ILogProvider>().Object;
builder.AddLogProvider(sp => logProvider);
var contextProvider = new Mock <IContextProvider>().Object;
builder.AddContextProvider(sp => contextProvider);
var serviceProvider = services.BuildServiceProvider();
var logger = builder.Build(serviceProvider);
logger.Should().BeOfType(ReloadingLoggerTests.ReloadingLogger);
logger.Level.Should().Be(LogLevel.Info);
logger.LogProviders.Should().ContainSingle()
.Which.Should().BeSameAs(logProvider);
logger.ContextProviders.Should().ContainSingle()
.Which.Should().BeSameAs(contextProvider);
}
private ServerConnector()
{
logger = LoggerBuilder.Init().Set(GetType()).Info("Connector Start!");
QueueThread.Push(() =>
{
while (true)
{
try
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
IPEndPoint ipep = new IPEndPoint(IPAddress.Parse(ServerInfo.GetIp()), ServerInfo.GetPort());
_socket.Connect(ipep);
ControlFactory.GetForm <Main>().SetConnection(true);
while (true)
{
byte[] size = new byte[4];
_socket.Receive(size, 4, SocketFlags.None);
byte[] data = new byte[BitConverter.ToInt32(size, 0)];
_socket.Receive(data, data.Length, SocketFlags.None);
String buf = Encoding.UTF8.GetString(data);
if (OnReceive != null)
{
logger.Info(" [NODE LOG] The data is recieved from node- " + buf);
OnReceive(buf);
}
}
}
catch (Exception e)
{
ControlFactory.GetForm <Main>().SetConnection(false);
logger.Error(" [SCRAP LOG] - " + e.ToString());
}
}
});
}
private ScrapListenner() : base(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP)
{
logger = LoggerBuilder.Init().Set(GetType()).Info("Listen Start!");
Bind(new IPEndPoint(IPAddress.Any, BrokerInfo.GetPort()));
Listen(20);
ThreadPool.QueueUserWorkItem((c) =>
{
while (true)
{
Socket client = Accept();
ThreadPool.QueueUserWorkItem((b) =>
{
Socket a = (Socket)b;
byte[] buffer = new byte[4];
a.Receive(buffer, 4, SocketFlags.None);
int size = BitConverter.ToInt32(buffer, 0);
buffer = new byte[size];
a.Receive(buffer, size, SocketFlags.None);
a.Send(new byte[] { 9 });
a.Close();
String msg = Encoding.UTF8.GetString(buffer);
logger.Info(" [WEB LOG] Send messate - " + msg);
Result result = Result.Build(msg);
//TODO: this function is that send just to get the message from the scraper to the server.
//the structure is key, ResultType, ScrapType, Index, Separation, Data.
ServerConnector.Instance().Send(buffer);
}, client);
}
});
}
public static int Main()
{
int functionReturnResult = -1;
using (var app = new App())
{
Action applicationAction =
() =>
{
app.InitializeComponent();
app.Run();
functionReturnResult = NormalApplicationExitCode;
};
using (var processor = new LogBasedExceptionProcessor(
LoggerBuilder.ForFile(
Path.Combine(FileConstants.LogPath(), DefaultErrorFileName),
new DebugLogTemplate(new NullConfiguration(), () => DateTimeOffset.Now))))
{
var result = TopLevelExceptionGuard.RunGuarded(
applicationAction,
new ExceptionProcessor[]
{
processor.Process,
});
return((result == GuardResult.Failure) ? UnhandledExceptionApplicationExitCode : functionReturnResult);
}
}
}
static void Main(string[] args)
{
LoggerBuilder builder = new LoggerBuilder();
SeqOptions seqOptions = new SeqOptions
{
Enabled = true,
Url = "http://localhost:5341"
};
Log.Logger = builder
.UseSuggestedSetting("RestSharp", "RestSharp.Easy")
.SetupSeq(seqOptions)
.BuildLogger();
Log.Logger.Error("TESTE");
var client = new EasyRestClient("http://pruu.herokuapp.com/dump", requestKey: "12345");
var body = new { test = "xxx", PersonTest = PersonTest.FirstName };
var result = client.SendRequestAsync <dynamic>(HttpMethod.Post, "restsharp-easy", body)
.GetAwaiter().GetResult();
var result2 = client.SendRequest <dynamic>(HttpMethod.Post, "restsharp-easy", body);
Thread.Sleep(5000);
}
public static void EnableDataDog_With_DataDogOptions()
{
// arrage
LoggerBuilder builder = new LoggerBuilder();
// act
builder.SetupDataDog(new DataDogOptions
{
Enabled = true,
MinimumLevel = LogEventLevel.Information,
ApiKey = "key",
Service = "service",
Source = "source",
Host = "host",
Tags = new string[] { "tags" }
});
var logger = builder.BuildLogger();
// assert
Assert.True(builder.OutputConfiguration.DataDog.Enabled);
Assert.NotNull(builder.OutputConfiguration.DataDog.Options.ApiKey);
Assert.NotNull(builder.OutputConfiguration.DataDog.Options.Host);
Assert.NotNull(builder.OutputConfiguration.DataDog.Options.Service);
Assert.NotNull(builder.OutputConfiguration.DataDog.Options.Source);
Assert.NotNull(builder.OutputConfiguration.DataDog.Options.Tags);
Assert.Single(builder.OutputConfiguration.DataDog.Options.Tags);
Assert.Equal("key", builder.OutputConfiguration.DataDog.Options.ApiKey);
Assert.Equal("service", builder.OutputConfiguration.DataDog.Options.Service);
Assert.Equal("source", builder.OutputConfiguration.DataDog.Options.Source);
Assert.Equal("host", builder.OutputConfiguration.DataDog.Options.Host);
Assert.Equal("tags", builder.OutputConfiguration.DataDog.Options.Tags[0]);
}
static void CheckParents(LoggerBuilderCollection builders,
LoggerBuilder lb, Logger logger) {
if (lb.ComputeParent(null).Length == 0) {
return;
}
HashSet<string> ancestors = new HashSet<string>();
LoggerBuilder current = lb;
StringBuilder forwards = new StringBuilder(current.Name);
while (current != null) {
if (!ancestors.Add(current.ComputeName())) {
Traceables.DetectedCycleInLogParents(forwards.ToString());
logger.ForwardToParentBlocked = true;
break;
}
string parent = current.ComputeParent(null);
if (parent.Length == 0)
break;
// Detect missing parents
current = builders[parent];
if (current == null) {
Traceables.MissingParentLoggerReference(lb.Name);
break;
}
forwards.Append(" -> " + parent);
}
}
public static void EnableSplunk_With_SplunkOptions()
{
// arrage
LoggerBuilder builder = new LoggerBuilder();
// act
builder.SetupSplunk(new SplunkOptions
{
Url = "http://www.google.com",
Enabled = true,
MinimumLevel = LogEventLevel.Verbose,
Application = "app",
Company = "company",
Index = "index",
ProcessName = "process",
ProductVersion = "1.0",
SourceType = "__json",
Token = "XXXXX"
});
var logger = builder.BuildLogger();
// assert
Assert.True(builder.OutputConfiguration.Splunk.Enabled);
Assert.True(builder.OutputConfiguration.Splunk.Options.Enabled);
Assert.NotNull(builder.OutputConfiguration.Splunk.Options.Url);
Assert.Equal("http://www.google.com", builder.OutputConfiguration.Splunk.Options.Url);
Assert.NotNull(builder.OutputConfiguration.Splunk.Options.Token);
Assert.Equal("XXXXX", builder.OutputConfiguration.Splunk.Options.Token);
Assert.Null(builder.OutputConfiguration.Splunk.Options.TextFormatter);
}
public void EnableDebug()
{
// arrage
LoggerBuilder builder = new LoggerBuilder();
builder.EnableDebug()
.EnableSeq("http://invalid");
var loggerConfiguration = builder.BuildConfiguration();
loggerConfiguration.WriteTo.XunitTestOutput(this.TestOutputHelper);
var logger = loggerConfiguration.CreateLogger();
Debugging.SelfLog.WriteLine("some log");
// act
logger.Verbose("SomeTest Build_Default_Logger");
// assert
// how validate serilog debug correctly?
Assert.Contains("SomeTest Build_Default_Logger", this.TestOutputHelper.Output);
// cleanup
builder.DisableDebug();
}
public void Build_Default_Logger()
{
// arrage
LoggerBuilder builder = new LoggerBuilder();
builder.SetMinimumLevel(LogEventLevel.Verbose).BuildConfiguration();
var loggerConfiguration = builder.BuildConfiguration();
loggerConfiguration.WriteTo.XunitTestOutput(this.TestOutputHelper);
var logger = loggerConfiguration.CreateLogger();
// act
logger.Verbose("SomeTest Build_Default_Logger");
// assert
Assert.Contains("SomeTest Build_Default_Logger", this.TestOutputHelper.Output);
Assert.False(builder.OutputConfiguration.Console.Enabled);
Assert.False(builder.OutputConfiguration.Seq.Enabled);
Assert.False(builder.OutputConfiguration.Splunk.Enabled);
Assert.False(builder.OutputConfiguration.NewRelic.Enabled);
Assert.False(builder.OutputConfiguration.DataDog.Enabled);
Assert.False(builder.OutputConfiguration.EnableEnrichWithEnvironment);
Assert.Empty(builder.OutputConfiguration.EnrichProperties);
Assert.Empty(builder.OutputConfiguration.OverrideMinimumLevel);
Assert.Equal(LogEventLevel.Verbose, builder.OutputConfiguration.MinimumLevel);
}
public void BuildMethodHappyPath3()
{
var services = new ServiceCollection();
var logProcessor = new Mock <ILogProcessor>().Object;
services.AddSingleton(logProcessor);
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>
{
{ "RockLib.Logging:Level", "Warn" },
{ "RockLib.Logging:LogProviders:Type", "RockLib.Logging.ConsoleLogProvider, RockLib.Logging" },
{ "RockLib.Logging:LogProviders:Value:Template", "foobar" }
})
.Build();
services.AddSingleton <IConfiguration>(configuration);
var builder = new LoggerBuilder(services, Logger.DefaultName, null);
var serviceProvider = services.BuildServiceProvider();
var logger = builder.Build(serviceProvider);
logger.Should().BeOfType <Logger>()
.Which.LogProcessor.Should().BeSameAs(logProcessor);
logger.Level.Should().Be(LogLevel.Warn);
logger.LogProviders.Should().ContainSingle()
.Which.Should().BeOfType <ConsoleLogProvider>()
.Which.Formatter.Should().BeOfType <TemplateLogFormatter>()
.Which.Template.Should().Be("foobar");
}
protected override IWebHostBuilder CreateWebHostBuilder()
{
var hostBuilder = WebHost.CreateDefaultBuilder()
.ConfigureAppConfiguration((context, builder) =>
{
var env = context.HostingEnvironment;
env.EnvironmentName = _options.Environment;
var configOptions = new ConfigurationOptions(env.ContentRootPath, env.EnvironmentName,
env.ApplicationName, new string[] { });
builder.ConfigureBuilder(configOptions);
})
.UseStartup <TStartup>()
.ConfigureServices(_options.ConfigureServices);
if (_options.EnableLoggingToFile)
{
hostBuilder.UseSerilog((context, configuration) =>
{
var loggerBuilder =
new LoggerBuilder(context.HostingEnvironment, context.Configuration, configuration)
.ConfigureLogger <TStartup>(c =>
c.FlushToDiskEveryInMs(1).SaveLogsTo(LogFilePath));
loggerBuilder.Build <TStartup>();
});
}
return(hostBuilder);
}
public void LoggerBuilder_With_One_LogGroup_Containing_One_RabbitMq_Destination_With_Custom_Components()
{
// Arrange
var connection = new Mock <IConnection>().Object;
var publicationAddressProvider = new Mock <IPublicationAddressProvider>().Object;
var logSerializer = new Mock <ILogSerializer>().Object;
var messagePublisher = new Mock <IMessagePublisher>().Object;
// Act
Logger logger = (Logger)LoggerBuilder.Logger().NewLogGroup("group1").ForAllLogs()
.RabbitMq()
.WithConnection(connection)
.WithAddress(publicationAddressProvider)
.WithLogSerializer(logSerializer)
.WithPublisher(messagePublisher)
.Add()
.BuildLogger();
// Assert
var logGroup = (LogGroup)logger.GetLogGroup("group1");
Assert.AreEqual(1, logGroup.LogDestinations.Count);
Assert.IsInstanceOf <RabbitMqDestination>(logGroup.LogDestinations[0]);
var rabbitMqDestination = (RabbitMqDestination)logGroup.LogDestinations[0];
// Connection asserts.
Assert.AreEqual(connection, rabbitMqDestination.RabbitMqConnection);
// Publication address provider asserts.
Assert.AreEqual(publicationAddressProvider, rabbitMqDestination.PublicationAddressProvider);
// Log serializer asserts.
Assert.AreEqual(logSerializer, rabbitMqDestination.LogSerializer);
// Message publisher asserts.
Assert.AreEqual(messagePublisher, rabbitMqDestination.MessagePublisher);
}
public void LoggerBuilder_With_RabbitMq_Destination_When_Log_Serializer_Is_Not_Specified_Sets_Default_Log_Serializer()
{
// Arrange
var connection = new Mock <IConnection>().Object;
var publicationAddressProvider = new Mock <IPublicationAddressProvider>().Object;
var messagePublisher = new Mock <IMessagePublisher>().Object;
// Act
Logger logger = (Logger)LoggerBuilder.Logger().NewLogGroup("group1").ForAllLogs()
.RabbitMq()
.WithConnection(connection)
.WithAddress(publicationAddressProvider)
.WithPublisher(messagePublisher)
.Add()
.BuildLogger();
// Assert
var logGroup = (LogGroup)logger.GetLogGroup("group1");
Assert.AreEqual(1, logGroup.LogDestinations.Count);
Assert.IsInstanceOf <RabbitMqDestination>(logGroup.LogDestinations[0]);
var rabbitMqDestination = (RabbitMqDestination)logGroup.LogDestinations[0];
// Log serializer asserts.
Assert.IsInstanceOf <JsonLogSerializer>(rabbitMqDestination.LogSerializer);
var logSerializer = (JsonLogSerializer)rabbitMqDestination.LogSerializer;
Assert.AreEqual(JsonLogSerializer.DefaultConverter, logSerializer.Converter);
Assert.AreEqual(JsonLogSerializer.DefaultJsonSerializerSettings, logSerializer.JsonSerializerSettings);
}
public static LoggerBuilder AddFileProvider(this LoggerBuilder builder, LogMessageLevel messageLevel = LogMessageLevel.All, string path = null, bool append = true)
{
LoggerOutputFileProvider fileProvider = new LoggerOutputFileProvider(path, append, messageLevel);
builder.AddOutputProvider(fileProvider, messageLevel);
return(builder);
}
public void WhenBuildingOnlyAConsoleLoggerShouldNotReturnAComposedLogger()
{
var logger = new LoggerBuilder().WithConsoleLogger()
.Build();
Assert.IsInstanceOfType(logger, typeof(ConsoleLogger));
}
public void WhenBuildingOnlyAFileLoggerShouldNotReturnAComposedLogger()
{
var logger = new LoggerBuilder().WithFileLogger("Some useless path")
.Build();
Assert.IsInstanceOfType(logger, typeof(FileLogger));
}
public void WhenBuildingOnlyADatabaseLoggerShouldNotReturnAComposedLogger()
{
var logger = new LoggerBuilder().WithDatabaseLogger("some useless connection string")
.Build();
Assert.IsInstanceOfType(logger, typeof(DatabaseLogger));
}
public static void SetupSerilog(
this IServiceCollection services,
string domain,
string application,
LoggerSettings settings,
IEnumerable <string> ignoredRoutes)
{
var loggerBuilder = new LoggerBuilder();
Log.Logger = loggerBuilder
.UseSuggestedSetting(domain, application)
.SetupSeq(settings?.SeqOptions)
.SetupSplunk(settings?.SplunkOptions)
.BuildLogger();
if (settings?.DebugEnabled ?? false)
{
loggerBuilder.EnableDebug();
}
var config = new SerilogConfiguration
{
InformationTitle = settings?.TitlePrefix + CommunicationLogger.DefaultInformationTitle,
ErrorTitle = settings?.TitlePrefix + CommunicationLogger.DefaultErrorTitle,
Blacklist = settings?.JsonBlacklist,
RequestKeyProperty = RequestKeyServiceExtension.RequestKeyHeaderName,
AccountIdProperty = AccountIdServiceExtension.AccountIdHeaderName,
TimeElapsedProperty = TimeElapsedServiceExtension.TimeElapsedHeaderName,
IgnoredRoutes = ignoredRoutes
};
services.SetupSerilog(config);
}
public void LoggerBuilder_With_RabbitMq_Destination_When_Message_Publisher_Not_Specified_Sets_Default_Message_Publisher()
{
// Arrange
var connection = new Mock <IConnection>().Object;
var publicationAddressProvider = new Mock <IPublicationAddressProvider>().Object;
var logSerializer = new Mock <ILogSerializer>().Object;
// Act
Logger logger = (Logger)LoggerBuilder.Logger().NewLogGroup("group1").ForAllLogs()
.RabbitMq()
.WithConnection(connection)
.WithAddress(publicationAddressProvider)
.WithLogSerializer(logSerializer)
.Add()
.BuildLogger();
// Assert
var logGroup = (LogGroup)logger.GetLogGroup("group1");
Assert.AreEqual(1, logGroup.LogDestinations.Count);
Assert.IsInstanceOf <RabbitMqDestination>(logGroup.LogDestinations[0]);
var rabbitMqDestination = (RabbitMqDestination)logGroup.LogDestinations[0];
// Message publisher asserts.
Assert.IsInstanceOf <BasicMessagePublisher>(rabbitMqDestination.MessagePublisher);
var messagePublisher = (BasicMessagePublisher)rabbitMqDestination.MessagePublisher;
Assert.AreEqual(null, messagePublisher.BasicProperties);
}
protected void SetupLogger(IPipelines pipelines, TinyIoCContainer container)
{
var loggerBuilder = new LoggerBuilder();
Log.Logger = loggerBuilder
.UseSuggestedSetting(Api.ApiSettings?.Domain, Api.ApiSettings?.Application)
.SetupSeq(Api.LogSettings?.SeqOptions)
.SetupSplunk(Api.LogSettings?.SplunkOptions)
.SetupGoogleCloudLogging(Api.LogSettings?.GoogleCloudLoggingOptions)
.BuildLogger();
var logger = container.Resolve <ICommunicationLogger>();
logger.NancySerilogConfiguration.InformationTitle =
Api.LogSettings?.TitlePrefix + CommunicationLogger.DefaultInformationTitle;
logger.NancySerilogConfiguration.ErrorTitle =
Api.LogSettings?.TitlePrefix + CommunicationLogger.DefaultErrorTitle;
logger.NancySerilogConfiguration.Blacklist = Api.LogSettings?.JsonBlacklist;
if (Api.LogSettings?.DebugEnabled ?? false)
{
loggerBuilder.EnableDebug();
}
pipelines.AddLogPipelines(container);
}
static void Main()
{
LoggerBuilder.Init(LogTemplate.GetLogTemp(ConfigSystem.ReadConfig("Config", "Log", "Path"))).Set("Server").Info("Server Program Start");
FactoryDao.CreateInstance(ConfigSystem.ReadConfig("Config", "DB", "Connection"), ConfigSystem.ReadConfig("Config", "Log", "Path"));
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
}
public Main()
{
logger = LoggerBuilder.Init().Set(GetType()).Info("Broker Program Start");
ControlFactory.SetForm(this);
InitializeComponent();
SetConnection(false);
SetMessage(false);
}
public void WhenBuildingWithConsoleLoggerWithMessageTypeShouldIncludeOnlyThoseTypes()
{
var logger = new LoggerBuilder().WithConsoleLogger(LogMessageType.Message, LogMessageType.Warning)
.Build() as ConsoleLogger;
Assert.AreEqual(2, logger.MessageTypesToBeLogged.Count());
Assert.IsTrue(logger.MessageTypesToBeLogged.Any(t => t == LogMessageType.Message));
Assert.IsTrue(logger.MessageTypesToBeLogged.Any(t => t == LogMessageType.Warning));
}
public Scraper(String parameter)
{
this.logger = LoggerBuilder.Init().Set(this.GetType());
base.StartInfo = new ProcessStartInfo();
base.StartInfo.FileName = "WebScraping.Scraper.exe";
this.parameter = SetParamter(parameter);
this.parameterStr = parameter;
this.logger.Info("Scraper process initialize Parameter : " + parameterStr);
}
public void Adding_Entity_Framework_Destination_With_Minimal_Configuration()
{
var logger = LoggerBuilder.Logger()
.ForAllLogs()
.EntityFramework()
.WithDbContext(dbContext)
.Add()
.BuildLogger();
}
public void WhenBuildingWithDatabaseLoggerWithMessageTypeShouldIncludeOnlyThoseTypes()
{
var logger = new LoggerBuilder().WithDatabaseLogger("soome useless directory", LogMessageType.Error, LogMessageType.Message)
.Build() as DatabaseLogger;
Assert.AreEqual(2, logger.MessageTypesToBeLogged.Count());
Assert.IsTrue(logger.MessageTypesToBeLogged.Any(t => t == LogMessageType.Error));
Assert.IsTrue(logger.MessageTypesToBeLogged.Any(t => t == LogMessageType.Message));
}
public void Adding_Entity_Framework_Destination_With_Custom_DbContext_Provider()
{
IDbContextProvider customDbContextProvider = new Mock <IDbContextProvider>().Object;
var logger = LoggerBuilder.Logger()
.ForAllLogs()
.EntityFramework()
.WithDbContext(customDbContextProvider)
.Add()
.BuildLogger();
}
public void Adding_RabbitMq_With_Minimal_Configuration()
{
var logger = LoggerBuilder.Logger()
.ForAllLogs()
.RabbitMq()
.WithConnection(connection)
.WithAddress("exchangeName", "exchangeType", "routingKey")
.Add()
.BuildLogger();
}
public ScrapExecutor(Parameter parameter)
{
logger = LoggerBuilder.Init().Set(GetType()).Info("ScrapExecutor call");
this.ResponseCode = new Response(parameter.Key);
base.StartInfo = new ProcessStartInfo();
base.StartInfo.FileName = parameter.Exec == ExecType.Only1Scraper ? "WebScraping.Only1Scraper.exe" : "WebScraping.Scraper.exe";
this.EnableRaisingEvents = true;
this.Parameter = parameter;
this.logger.Info(" [NODE LOG] The excuter is generated");
}
