public static Logger bound_to(object object_that_needs_logging)
{
initialize_logger_dictionary_if_not_created();
Logger logger;
try
{
if (log_dictionary.ContainsKey(object_that_needs_logging))
{
logger = log_dictionary[object_that_needs_logging];
}
else
{
logger = Container.get_an_instance_of<LogFactory>().create_logger_bound_to(object_that_needs_logging);
add_to_dictionary(object_that_needs_logging, logger);
}
}
catch (Exception)
{
logger = new Log4NetLogger(LogManager.GetLogger(object_that_needs_logging.ToString()));
add_to_dictionary(object_that_needs_logging, logger);
if (!have_displayed_error_message)
{
logger.log_a_warning_event_containing("Logging wasn't set up in the container. Defaulting to log4net.");
have_displayed_error_message = true;
}
}
return logger;
}
static void Main(string[] args)
{
var exitHandle = new ManualResetEvent(false);
var logger = new Log4NetLogger();
var utilServer = new UtilServer(logger, exitHandle);
var windowsService = new UtilsWindowsService(utilServer, logger);
if (args.Length == 0)
{
ServiceBase.Run(windowsService);
}
else switch (args[0])
{
case "console":
utilServer.Start();
Console.CancelKeyPress += (s, e) =>
{
e.Cancel = true;
utilServer.Stop();
};
break;
case "install":
if (!windowsService.IsInstalled())
windowsService.Install();
break;
case "uninstall":
if (windowsService.IsInstalled())
windowsService.Uninstall();
break;
}
}
public void ConstructorShouldSetInnerLog()
{
var expected = new Mock<log4net.ILog>().Object;
Log4NetLogger tested = new Log4NetLogger(expected);
var actual = tested.log;
Assert.IsNotNull(actual);
Assert.AreSame(expected, actual);
}
public void FatalShouldForwardsMessageToInnerFatal()
{
var message = "somemessage";
var mockLog = new Mock<log4net.ILog>();
mockLog.Setup(x => x.Fatal(message)).Verifiable();
ILog tested = new Log4NetLogger(mockLog.Object);
tested.Fatal(message);
mockLog.Verify();
}
public void CanWriteToLoggerInWarnCategory()
{
ILoggerFacade logger = new Log4NetLogger();
logger.Log("Test", Category.Warn, Priority.Low);
string output = appender.GetString();
StringAssert.Contains(output, "Test");
StringAssert.Contains(output, "WARN");
}
public void CanWriteToLoggerInErrorCategory()
{
ILoggerFacade logger = new Log4NetLogger();
logger.Log("Test", Category.Exception, Priority.Low);
string output = appender.GetString();
StringAssert.Contains(output, "Test");
StringAssert.Contains(output, "ERROR");
}
public void FormattedDebugShouldForwardsMessageToInnerDebugFormat()
{
var format = "formatted message";
var args = new object[] { "arg1", "arg2" };
var provider = new Mock<IFormatProvider>().Object;
var mockLog = new Mock<log4net.ILog>();
mockLog.Setup(x => x.DebugFormat(provider, format, args)).Verifiable();
ILog tested = new Log4NetLogger(mockLog.Object);
tested.Debug(provider, format, args);
mockLog.Verify();
}
public void SimpleLogTest()
{
var myLogger = new Log4NetLogger(typeof(Log4NetLogger));
myLogger.Debug("FooBar");
myLogger.Warning("FooBar");
myLogger.Error("FooBar");
myLogger.Error(new Exception(), "FooBar");
myLogger.Info("FooBar");
myLogger.Info("FooBar", "Bar");
Assert.AreEqual(myLogger.IsDebugEnabled, myLogger.IsDebugEnabled); // We don't care about the actual value.
}
public IEnumerable <WeatherForecast> GetWeatherForecast()
{
var rng = new Random();
Log4NetLogger.Info(rng.ToString());
return(Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToArray());
}
public static IServiceBus CreateBus(string queueName, Action <ServiceBusConfigurator> moreInitialization)
{
Log4NetLogger.Use();
var bus = ServiceBusFactory.New(x =>
{
x.UseRabbitMq();
//x.UseJsonSerializer();
x.ReceiveFrom("rabbitmq://localhost/OpcEsb_" + queueName);
moreInitialization(x);
});
return(bus);
}
public Startup(IWebHostEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
Configuration = builder.Build();
_cancellationTokenSource = new CancellationTokenSource();
_logger = new Log4NetLogger(null);
_logger.Initialize(nameof(Startup), "log4net.xml");
}
public VTuberRankingService(
YouTubeService youtubeService,
YouTubeBlobService youtubeBlobService,
VTuberInsightCrawler vtuberInsightCrawler,
YouTubeChannelRssCrawler youtubeChannelRssCrawler,
Log4NetLogger log)
{
this.youtubeService = youtubeService;
this.youtubeBlobService = youtubeBlobService;
this.vtuberInsightCrawler = vtuberInsightCrawler;
this.youtubeChannelRssCrawler = youtubeChannelRssCrawler;
this.log = log;
}
public void Log_Should_IgnoreMessage_When_Empty()
{
Log4NetProviderOptions options = ConfigureOptions(Log4NetFileOption.TestAppenderTrace);
var testAppender = GetTestAppender(options);
var sut = new Log4NetLogger(options);
sut.Log(LogLevel.Trace, _eventId, string.Empty, null, (message, exception) => message);
testAppender.GetEvents()
.Should()
.BeEmpty();
}
public void Log_Should_Not_IgnoreMessage_When_Empty_For_Non_Null_Exception()
{
Log4NetProviderOptions options = ConfigureOptions(Log4NetFileOption.TestAppenderTrace);
var testAppender = GetTestAppender(options);
var sut = new Log4NetLogger(options);
sut.Log(LogLevel.Trace, _eventId, string.Empty, new Exception("Something went wrong"), (message, exception) => message);
testAppender.GetEvents()
.Should()
.NotBeEmpty();
}
public void Log_Should_IgnoreMessage_With_LevelNone()
{
var options = ConfigureOptions(Log4NetFileOption.TestAppenderTrace);
var testAppender = GetTestAppender(options);
var sut = new Log4NetLogger(options);
sut.Log(LogLevel.None, _eventId, _logState, null, (message, exception) => message);
testAppender.GetEvents()
.Should()
.BeEmpty();
}
public async Task OnInstanceUpdatedAsync(string instanceId, string user, string projectId = null)
{
Log4NetLogger.Use();
var updatedInstance = await _jiraService.ReadInstanceAsync(instanceId);
updatedInstance.MessageOrigin = GetMessageOrigin();
updatedInstance.Action = "Updated";
updatedInstance.ModifiedUser = await _dbService.GetClientUserFrom(_config.UserColumnName, user);
Debug.WriteLine("Publishing updated instance from " + GetMessageOrigin() + " with id: " + instanceId);
await PublishInstance(updatedInstance);
}
public void FormattedDebugShouldForwardsMessageToInnerDebugFormat()
{
var format = "formatted message";
var args = new object[] { "arg1", "arg2" };
var provider = new Mock <IFormatProvider>().Object;
var mockLog = new Mock <log4net.ILog>();
mockLog.Setup(x => x.DebugFormat(provider, format, args)).Verifiable();
ILog tested = new Log4NetLogger(mockLog.Object);
tested.Debug(provider, format, args);
mockLog.Verify();
}
public void Test_Construct_WithContextName_ShouldSetUpContextName()
{
//---------------Set up test pack-------------------
var contextName = TestUtil.GetRandomString();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var logger = new Log4NetLogger(contextName);
//---------------Test Result -----------------------
Assert.IsInstanceOf <IHabaneroLogger>(logger);
Assert.AreEqual(contextName, logger.ContextName);
}
public void BeginScope_Should_Include_CustomScopeState_In_LoggedMessage()
{
const string CustomScope = "CustomScope";
var mockedFactory = new Mock <ILog4NetScopeFactory>(MockBehavior.Default);
mockedFactory.Setup(x => x.BeginScope(It.IsAny <string>()))
.Returns(new Log4NetScope(CustomScope, new Log4NetScopeRegistry()));
var options = ConfigureOptions(Log4NetFileOption.TestAppenderTrace);
options.ScopeFactory = mockedFactory.Object;
var testAppender = GetTestAppender(options);
var sut = new Log4NetLogger(options);
using (var scope = sut.BeginScope(CustomScope))
{
sut.Log(LogLevel.Critical, _eventId, _logState, null, (message, exception) => message);
}
sut.Log(LogLevel.Critical, _eventId, _logState, null, (message, exception) => message);
// https://stackoverflow.com/questions/14438217/memoryappender-patternlayout-not-rendering
testAppender.GetEvents()
.Should()
.NotBeEmpty()
.And
.HaveCount(2);
testAppender.GetEvents()
.First()
.Level
.Should()
.Be(Level.Fatal);
var textWriter = new StringWriter();
testAppender.Layout.Format(textWriter, testAppender.GetEvents().First());
textWriter.ToString()
.Should()
.Contain(_logState);
textWriter.ToString()
.Should()
.Contain(CustomScope);
textWriter.Close();
textWriter = new StringWriter();
testAppender.Layout.Format(textWriter, testAppender.GetEvents().Last());
textWriter.ToString()
.Should()
.NotContain(CustomScope);
}
public void Debug_NoMessage()
{
// Prepare
const string message = "Simple Message";
logger.SetupGet(o => o.IsDebugEnabled).Returns(() => false);
logger.Setup(o => o.Debug(message)).Callback(() => counterCall++);
log = new Log4NetLogger(logger.Object);
// Act
log.Debug(message);
// Assert
Assert.AreEqual(counterCall, 0);
}
public void Debug_MessageOnly()
{
// Prepare
const string message = "Simple Message";
logger.SetupGet(o => o.IsDebugEnabled).Returns(() => true);
logger.Setup(o => o.Debug(message)).Verifiable();
log = new Log4NetLogger(logger.Object);
// Act
log.Debug(message);
// Assert
logger.VerifyAll();
}
public void log_with_calls_fatal_calls_the_correct_loglevel_method()
{
// Arrange
var logger = new Log4NetLogger("TestLogger")
{
Logger = GetFakeLogger()
};
// Act
logger.Log(LogLevel.Critical, new EventId(), "Fatal log", null, null);
// Assert
logger.Logger.Received(1).Fatal("Fatal log", null);
}
public void log_with_calls_invalid_level_does_not_call_fatal()
{
// Arrange
var logger = new Log4NetLogger("TestLogger")
{
Logger = GetFakeLogger()
};
// Act
logger.Log((LogLevel)99, new EventId(), "Invalid log", null, null);
// Assert
logger.Logger.DidNotReceive().Fatal("Invalid log", null);
}
public void LoggerDebugDisabled()
{
// Arrange
var logMock = new Mock <ILog>();
logMock.Setup(m => m.IsDebugEnabled).Returns(false);
var logger = new Log4NetLogger(logMock.Object);
// Act
var isEnabled = logger.IsEnabled(LogLevel.Debug);
// Assert
Assert.False(isEnabled);
}
public void log_with_calls_info_calls_the_correct_loglevel_method()
{
// Arrange
var logger = new Log4NetLogger("TestLogger")
{
Logger = GetFakeLogger()
};
// Act
logger.Log(LogLevel.Information, new EventId(), "Info log", null, null);
// Assert
logger.Logger.Received(1).Info("Info log", null);
}
public void log_with_calls_error_calls_the_correct_loglevel_method()
{
// Arrange
var logger = new Log4NetLogger("TestLogger")
{
Logger = GetFakeLogger()
};
// Act
logger.Log(LogLevel.Error, new EventId(), "Error log", null, null);
// Assert
logger.Logger.Received(1).Error("Error log", null);
}
public void UpdatePhases(List <OfferPhases> listOfferPhases, int IdOffer)
{
OfferRepository <OfferPhases> Offerrepo = new OfferRepository <OfferPhases>();
Offerrepo.UpdatePhases(listOfferPhases, IdOffer);
Log4NetLogger logger2 = new Log4NetLogger();
SUser suser = new SUser();
foreach (var oferfases in listOfferPhases)
{
var user = suser.GetUserById(new Guid(oferfases.Offer.IdUser));
logger2.Info("Actualización Fases Oferta:" + IdOffer + "," + "UsuarioOrigen:" + user.UserName + ",Fase:" + oferfases.Name);
}
}
static int Main()
{
Log4NetLogger.Use("worker.log4net.config");
Log4NetLogWriterFactory.Use();
return((int)HostFactory.Run(c =>
{
c.SetServiceName("Grid.Distributor.Worker");
c.RunAsLocalSystem();
c.Service <WorkerService>();
}));
}
public void CallingMethods()
{
var logMock = new LogMock();
var logger = new Log4NetLogger(logMock);
var b = logger.IsDebugEnabled;
b = logger.IsErrorEnabled;
b = logger.IsFatalEnabled;
b = logger.IsInfoEnabled;
b = logger.IsWarnEnabled;
logger.Debug(null);
logger.Debug(null, null);
logger.DebugFormat(null, null);
logger.Error(null);
logger.Error(null, null);
logger.ErrorFormat(null, null);
logger.Warn(null);
logger.Warn(null, null);
logger.WarnFormat(null, null);
logger.Info(null);
logger.Info(null, null);
logger.InfoFormat(null, null);
logger.Fatal(null);
logger.Fatal(null, null);
Assert.That(logMock.debug, Is.EqualTo(1));
Assert.That(logMock.debugException, Is.EqualTo(1));
Assert.That(logMock.debugFormat, Is.EqualTo(1));
Assert.That(logMock.info, Is.EqualTo(1));
Assert.That(logMock.infoException, Is.EqualTo(1));
Assert.That(logMock.infoFormat, Is.EqualTo(1));
Assert.That(logMock.warn, Is.EqualTo(1));
Assert.That(logMock.warnException, Is.EqualTo(1));
Assert.That(logMock.warnFormat, Is.EqualTo(1));
Assert.That(logMock.error, Is.EqualTo(1));
Assert.That(logMock.errorException, Is.EqualTo(1));
Assert.That(logMock.errorFormat, Is.EqualTo(1));
Assert.That(logMock.fatal, Is.EqualTo(1));
Assert.That(logMock.fatalException, Is.EqualTo(1));
Assert.That(logMock.isDebugEnabled, Is.GreaterThan(1));
Assert.That(logMock.isInfoEnabled, Is.GreaterThan(1));
Assert.That(logMock.isWarnEnabled, Is.GreaterThan(1));
Assert.That(logMock.isErrorEnabled, Is.GreaterThan(1));
Assert.That(logMock.isFatalEnabled, Is.GreaterThan(1));
}
/// <summary>
/// Specify that log4net should be used for logging MassTransit messages
/// </summary>
/// <param name="configurator"></param>
/// <param name="configFileName">The name of the log4net xml configuration file</param>
public static void UseLog4Net(this IBusFactoryConfigurator configurator, string configFileName)
{
Log4NetLogger.Use();
string path = AppDomain.CurrentDomain.BaseDirectory;
string file = Path.Combine(path, configFileName);
var configFile = new FileInfo(file);
if (configFile.Exists)
{
Log4NetLogger.Use(file);
}
}
static void Main()
{
Log4NetLogger.Use("barista.log4net.xml");
var container = new WindsorContainer();
container.Register(
Component.For(typeof(ISagaRepository <>))
.ImplementedBy(typeof(InMemorySagaRepository <>))
.LifeStyle.Singleton,
Component.For <DrinkPreparationSaga>(),
Component.For <BaristaService>()
.LifeStyle.Singleton,
Component.For <IServiceBus>().UsingFactoryMethod(() =>
{
return(ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom("msmq://localhost/starbucks_barista");
sbc.UseMsmq();
sbc.UseMulticastSubscriptionClient();
sbc.UseControlBus();
sbc.Subscribe(subs => { subs.LoadFrom(container); });
}));
}).LifeStyle.Singleton);
HostFactory.Run(c =>
{
c.SetServiceName("StarbucksBarista");
c.SetDisplayName("Starbucks Barista");
c.SetDescription("a Mass Transit sample service for making orders of coffee.");
c.DependsOnMsmq();
c.RunAsLocalService();
DisplayStateMachine();
c.Service <BaristaService>(s =>
{
s.ConstructUsing(builder => container.Resolve <BaristaService>());
s.WhenStarted(o => o.Start());
s.WhenStopped(o =>
{
o.Stop();
container.Dispose();
});
});
});
}
protected IContainer build_the_container()
{
IWindsorContainer windsor_container = new WindsorContainer();
infrastructure.logging.ILog nant_logger = new NAntLogger(this);
infrastructure.logging.ILog log4net_logger = new Log4NetLogger(the_logger);
infrastructure.logging.ILog multi_logger = new MultipleLogger(new List<infrastructure.logging.ILog> { nant_logger, log4net_logger });
windsor_container.Kernel.AddComponentInstance<infrastructure.logging.ILog>(multi_logger);
windsor_container.AddComponent<IFileSystemAccess, WindowsFileSystemAccess>();
windsor_container.AddComponent<ILogFactory, MultipleLoggerLogFactory>();
return new infrastructure.containers.custom.WindsorContainer(windsor_container);
}
public void CallingMethods()
{
var logMock = new LogMock();
var logger = new Log4NetLogger(logMock);
var b = logger.IsDebugEnabled;
b = logger.IsErrorEnabled;
b = logger.IsFatalEnabled;
b = logger.IsInfoEnabled;
b = logger.IsWarnEnabled;
logger.Debug(null);
logger.Debug(null, null);
logger.DebugFormat(null, null);
logger.Error(null);
logger.Error(null, null);
logger.ErrorFormat(null, null);
logger.Warn(null);
logger.Warn(null, null);
logger.WarnFormat(null, null);
logger.Info(null);
logger.Info(null, null);
logger.InfoFormat(null, null);
logger.Fatal(null);
logger.Fatal(null, null);
logMock.debug.Should().Be(1);
logMock.debugException.Should().Be(1);
logMock.debugFormat.Should().Be(1);
logMock.info.Should().Be(1);
logMock.infoException.Should().Be(1);
logMock.infoFormat.Should().Be(1);
logMock.warn.Should().Be(1);
logMock.warnException.Should().Be(1);
logMock.warnFormat.Should().Be(1);
logMock.error.Should().Be(1);
logMock.errorException.Should().Be(1);
logMock.errorFormat.Should().Be(1);
logMock.fatal.Should().Be(1);
logMock.fatalException.Should().Be(1);
logMock.isDebugEnabled.Should().Be.GreaterThan(1);
logMock.isInfoEnabled.Should().Be.GreaterThan(1);
logMock.isWarnEnabled.Should().Be.GreaterThan(1);
logMock.isErrorEnabled.Should().Be.GreaterThan(1);
logMock.isFatalEnabled.Should().Be.GreaterThan(1);
}
static void Main()
{
Log4NetLogger.Use("cashier.log4net.xml");
var container = new UnityContainer();
// register types directly
container.RegisterType <CashierService>(new ContainerControlledLifetimeManager());
container.RegisterType(typeof(ISagaRepository <>), typeof(InMemorySagaRepository <>), new ContainerControlledLifetimeManager());
// Register the ServiceBus.
container.RegisterInstance <IServiceBus>(ServiceBusFactory.New(sbc =>
{
// Configure exchanges.
sbc.ReceiveFrom("msmq://localhost/starbucks_cashier");
sbc.UseMsmq();
sbc.UseMulticastSubscriptionClient();
sbc.SetConcurrentConsumerLimit(1); //a cashier cannot multi-task
sbc.UseControlBus();
sbc.EnableRemoteIntrospection();
sbc.Subscribe(subs => { subs.LoadFrom(container); });
}));
HostFactory.Run(c =>
{
c.SetServiceName("StarbucksCashier");
c.SetDisplayName("Starbucks Cashier");
c.SetDescription("a Mass Transit sample service for handling orders of coffee..");
c.DependsOnMsmq();
c.RunAsLocalService();
DisplayStateMachine();
c.Service <CashierService>(s =>
{
s.ConstructUsing(builder => container.Resolve <CashierService>());
s.WhenStarted(o => o.Start());
s.WhenStopped(o =>
{
o.Stop();
container.Dispose();
});
});
});
}
public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel)
{
request = TransformMessage(request);
MessageBuffer buffer = request.CreateBufferedCopy(int.MaxValue);
Message copy = buffer.CreateMessage();
var logger = Log4NetLogger.Configure();
logger.Information(GetDocumentFromMessage(buffer.CreateMessage()).OuterXml);
request = buffer.CreateMessage();
return(null);
}
void Application_Start(object sender, EventArgs e)
{
// 在应用程序启动时运行的代码
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
// Code that runs on application startup
Log4NetLogger.GetLogger().Info("Application_Start....");
SqlHelper.ConnectionStringSettings = ConfigurationManager.ConnectionStrings["DBConnection"].ConnectionString;
Log4NetLogger.GetLogger().Info("ConnectionStringSettings: " + SqlHelper.ConnectionStringSettings);
System.Threading.Thread t = new System.Threading.Thread(TempImgLRU);
t.Start();
}
private ILogger CreateGlobalLoggerForService(string instanceName)
{
Constraint.MustNotBeNull(Configuration, "Configuration");
var logFilePath = Configuration.GetStringValue(GlobalSettings.Keys.LogFilePath);
// ReSharper disable once AssignNullToNotNullAttribute
logFilePath = string.Format(logFilePath, string.Format(".{0}", instanceName));
logFilePath = PathHelp.RootPathIfRelative(logFilePath, AppDomain.CurrentDomain.BaseDirectory);
return(Log4NetLogger.GetLogger(ExeAppSettings.FilePath,
Appenders.Trace(),
Appenders.ColouredConsole(),
Appenders.EventLog(EventLogSource),
Appenders.RollingFile(logFilePath, true)));
}
public void TestConsumer()
{
Log4NetLogger.Use("Log4Net/log4net.config");
string rabbitMqUri = "rabbitmq://localhost:5672";
string rabbitMqUserName = "";
string rabbitMqPassword = "";
string queueName = "order.queue";
var busControl = ServiceBusManager.Instance.UseRabbitMq(rabbitMqUri, rabbitMqUserName, rabbitMqPassword)
.RegisterConsumer <SubmitOrderCommandConsumer>(queueName)
.RegisterConsumer <OrderSubmittedEventConsumer>(null)
.Build();
busControl.Start();
}
public async Task <IHttpActionResult> GetCategoriesById(int id)
{
Log4NetLogger logger = new Log4NetLogger();
logger.Info("Hi There this is naveen");
var clientRequests = await _categoryManager.GetById(id);
if (clientRequests == null)
{
return(NotFound());
}
return(Ok(clientRequests));
}
public void Debug_LambdaMessage()
{
// Prepare
const string message = "Simple Message";
logger.SetupGet(o => o.IsDebugEnabled).Returns(() => true);
logger.Setup(o => o.Debug(message)).Verifiable();
log = new Log4NetLogger(logger.Object);
// Act
log.Debug(() => message);
// Assert
logger.VerifyAll();
}
public void Debug_NoMessage()
{
// Prepare
const string message = "Simple Message";
logger.SetupGet(o => o.IsDebugEnabled).Returns(() => false);
logger.Setup(o => o.Debug(message)).Callback(() => counterCall++);
log = new Log4NetLogger(logger.Object);
// Act
log.Debug(message);
// Assert
Assert.AreEqual(counterCall, 0);
}
public void FormatCaller_Message()
{
// Prepare
const string memberName = "FormatCaller_Message";
const string sourceFilePath = "Log4NetUnitTest.cs";
const int sourceLineNumber = 45;
const string format = "File: {0,50} Method:{1,40}";
logger.SetupGet(o => o.IsDebugEnabled).Returns(() => true);
log = new Log4NetLogger(logger.Object);
// Act
var result = log.FormatCallerMessage(memberName,sourceFilePath,sourceLineNumber);
// Assert
Assert.That(result.Contains(string.Format(format,sourceFilePath,memberName)));
}
public static Logger bound_to(object object_that_needs_logging)
{
Logger logger;
try
{
logger = Container.get_an_instance_of<LogFactory>().create_logger_bound_to(object_that_needs_logging);
}
catch(Exception)
{
if(!have_displayed_error_message)
{
have_displayed_error_message = true;
}
logger = new Log4NetLogger(LogManager.GetLogger(object_that_needs_logging.ToString()));
}
return logger;
}
public static Logger bound_to(object object_that_needs_logging)
{
Logger logger;
try
{
logger = Container.get_an_instance_of<LogFactory>().create_logger_bound_to(object_that_needs_logging);
}
catch(Exception)
{
if(!have_displayed_error_message)
{
//Console.WriteLine(
// "Creating the default logger with log4Net. Please register an LoggerFactory in the container if you would like to use something else.");
have_displayed_error_message = true;
}
logger = new Log4NetLogger(LogManager.GetLogger(object_that_needs_logging.ToString()));
}
return logger;
}
private static Logger GetMultiLogger(ConfigurationPropertyHolder configuration_property_holder)
{
IList<Logger> loggers = new List<Logger>();
var task = configuration_property_holder as ITask;
if (task != null)
{
Logger msbuild_logger = new MSBuildLogger(configuration_property_holder);
loggers.Add(msbuild_logger);
}
Logger log4net_logger = new Log4NetLogger(LogManager.GetLogger("roundhouse"));
loggers.Add(log4net_logger);
if (configuration_property_holder.Logger != null && !loggers.Contains(configuration_property_holder.Logger))
{
loggers.Add(configuration_property_holder.Logger);
}
return new MultipleLogger(loggers);
}
public void SetUp()
{
log = new Mock<ILog>();
logger = new Log4NetLogger(log.Object);
}
public void Warn_NoMessage()
{
// Prepare
const string message = "Simple Warn";
logger.SetupGet(o => o.IsWarnEnabled).Returns(() => false);
logger.Setup(o => o.Warn(message)).Callback(() => counterCall++).Verifiable();
log = new Log4NetLogger(logger.Object);
// Act
log.Warn(message);
// Assert
Assert.AreEqual(counterCall, 0);
}
public void Warn_LambdaMessage()
{
// Prepare
const string message = "Simple Warn";
logger.SetupGet(o => o.IsWarnEnabled).Returns(() => true);
logger.Setup(o => o.Warn(message)).Verifiable();
log = new Log4NetLogger(logger.Object);
// Act
log.Warn(() => message);
// Assert
logger.VerifyAll();
}
public void should_return_email_config()
{
var logger = new Log4NetLogger();
logger.Email.ShouldEqual("*****@*****.**");
logger.SmtpServer.ShouldEqual("smtp.test.com");
}
public void should_return_file_config()
{
var logger = new Log4NetLogger();
logger.Path.ShouldEqual(Path.GetFullPath("Volta.Web.log"));
}
public void TearDown()
{
logger = null;
log = null;
}
public void Warn_FormatMessage()
{
// Prepare
const string format = "Number of Call: {0} occurred";
logger.SetupGet(o => o.IsWarnEnabled).Returns(() => true);
logger.Setup(o => o.WarnFormat(format, new object[] { 1 })).Verifiable();
log = new Log4NetLogger(logger.Object);
// Act
log.WarnFormat(format, 1);
// Assert
logger.VerifyAll();
}
public void CallingMethods()
{
var logMock = new LogMock();
var logger = new Log4NetLogger(logMock);
var b = logger.IsDebugEnabled;
b = logger.IsErrorEnabled;
b = logger.IsFatalEnabled;
b = logger.IsInfoEnabled;
b = logger.IsWarnEnabled;
logger.Debug(null);
logger.Debug(null, null);
logger.DebugFormat(null, null);
logger.Error(null);
logger.Error(null, null);
logger.ErrorFormat(null, null);
logger.Warn(null);
logger.Warn(null, null);
logger.WarnFormat(null, null);
logger.Info(null);
logger.Info(null, null);
logger.InfoFormat(null, null);
logger.Fatal(null);
logger.Fatal(null, null);
Assert.That(logMock.debug, Is.EqualTo(1));
Assert.That(logMock.debugException, Is.EqualTo(1));
Assert.That(logMock.debugFormat, Is.EqualTo(1));
Assert.That(logMock.info, Is.EqualTo(1));
Assert.That(logMock.infoException, Is.EqualTo(1));
Assert.That(logMock.infoFormat, Is.EqualTo(1));
Assert.That(logMock.warn, Is.EqualTo(1));
Assert.That(logMock.warnException, Is.EqualTo(1));
Assert.That(logMock.warnFormat, Is.EqualTo(1));
Assert.That(logMock.error, Is.EqualTo(1));
Assert.That(logMock.errorException, Is.EqualTo(1));
Assert.That(logMock.errorFormat, Is.EqualTo(1));
Assert.That(logMock.fatal, Is.EqualTo(1));
Assert.That(logMock.fatalException, Is.EqualTo(1));
Assert.That(logMock.isDebugEnabled, Is.GreaterThan(1));
Assert.That(logMock.isInfoEnabled, Is.GreaterThan(1));
Assert.That(logMock.isWarnEnabled, Is.GreaterThan(1));
Assert.That(logMock.isErrorEnabled, Is.GreaterThan(1));
Assert.That(logMock.isFatalEnabled, Is.GreaterThan(1));
}
public void CallingMethods()
{
var logMock = new LogMock();
var logger = new Log4NetLogger(logMock);
var b = logger.IsDebugEnabled;
b = logger.IsErrorEnabled;
b = logger.IsFatalEnabled;
b = logger.IsInfoEnabled;
b = logger.IsWarnEnabled;
logger.Debug(null);
logger.Debug(null, null);
logger.DebugFormat(null, null);
logger.Error(null);
logger.Error(null, null);
logger.ErrorFormat(null, null);
logger.Warn(null);
logger.Warn(null, null);
logger.WarnFormat(null, null);
logger.Info(null);
logger.Info(null, null);
logger.InfoFormat(null, null);
logger.Fatal(null);
logger.Fatal(null, null);
logMock.debug.Should().Be(1);
logMock.debugException.Should().Be(1);
logMock.debugFormat.Should().Be(1);
logMock.info.Should().Be(1);
logMock.infoException.Should().Be(1);
logMock.infoFormat.Should().Be(1);
logMock.warn.Should().Be(1);
logMock.warnException.Should().Be(1);
logMock.warnFormat.Should().Be(1);
logMock.error.Should().Be(1);
logMock.errorException.Should().Be(1);
logMock.errorFormat.Should().Be(1);
logMock.fatal.Should().Be(1);
logMock.fatalException.Should().Be(1);
logMock.isDebugEnabled.Should().Be.GreaterThan(1);
logMock.isInfoEnabled.Should().Be.GreaterThan(1);
logMock.isWarnEnabled.Should().Be.GreaterThan(1);
logMock.isErrorEnabled.Should().Be.GreaterThan(1);
logMock.isFatalEnabled.Should().Be.GreaterThan(1);
}
public void Debug_MessageWithException()
{
// Prepare
const string message = "Exception occurred";
var ex = new Exception(message);
logger.SetupGet(o => o.IsDebugEnabled).Returns(() => true);
logger.Setup(o => o.Debug(message, ex)).Verifiable();
log = new Log4NetLogger(logger.Object);
// Act
log.Debug(message, ex);
// Assert
logger.VerifyAll();
}
