/// <summary>
/// Initializes a new instance of the <see cref="ErrorLogger"/> class.
/// </summary>
public ErrorLogger()
{
m_logToScreenshot = DefaultLogToScreenshot;
// Initialize all logger methods.
Loggers.Add(ExceptionToScreenshot);
}
//public void Intercept(IInvocation invocation)
//{
// if (Logger.IsDebugEnabled)
// Logger.Debug(CreateInvocationLogString(invocation));
// try
// {
// invocation.Proceed();
// }
// catch (Exception ex)
// {
// if (Logger.IsErrorEnabled) Logger.Error(CreateInvocationLogString(invocation), ex);
// throw;
// }
//}
public void Intercept(IInvocation invocation)
{
if (!Loggers.ContainsKey(invocation.TargetType))
{
Loggers.Add(invocation.TargetType, LoggerFactory.Create(invocation.TargetType));
}
ILogger logger = Loggers[invocation.TargetType];
if (logger.IsDebugEnabled)
{
logger.Debug(CreateInvocationLogString(invocation));
}
try
{
invocation.Proceed();
}
catch (Exception ex)
{
if (Logger.IsErrorEnabled)
{
Logger.Error(CreateInvocationLogString(invocation), ex);
}
throw;
}
}
public ILogger CreateLogger(string categoryName)
{
var logger = new TestLogger();
Loggers.Add(logger);
return(logger);
}
static BaCon()
{
// Guess which theme we should use.
switch (Console.BackgroundColor)
{
case ConsoleColor.Black:
case ConsoleColor.Blue:
case ConsoleColor.DarkBlue:
case ConsoleColor.DarkCyan:
case ConsoleColor.DarkGray:
case ConsoleColor.DarkGreen:
case ConsoleColor.DarkMagenta:
case ConsoleColor.DarkRed:
Theme = BaConTheme.DarkTheme;
break;
default:
Theme = BaConTheme.LightTheme;
break;
}
// Default to Console logger.
// This allows the logging functions to work as expected without effort.
// If somebody doesn't want the console logger, they can disable it with a line of code.
Loggers.Add(new BaConConsoleLogger());
}
public void AddLogger(Action <string> logger)
{
if (logger != null)
{
Loggers.Add(logger);
}
}
public void RegisterLogger(ILogger logger)
{
if (logger == null)
{
return;
}
Loggers.Add(logger.GetType(), logger);
}
/// <summary>
/// Provides re-try logic, logging mechanism, screenshot storing and other basic functionality of Selenium tests.
/// </summary>
public SeleniumTestBase()
{
if (SeleniumTestsConfiguration.TestContextLogger)
{
var logger = Loggers.FirstOrDefault(s => s is TestContextLogger);
Loggers.Remove(logger);
Loggers.Add(new TestContextLogger(this));
}
}
public static ILogger Get <T>()
{
if (!Loggers.ContainsKey(typeof(T)))
{
Loggers.Add(typeof(T), LoggerFactory.CreateLogger <T>());
}
return(Loggers[typeof(T)]);
}
/// <summary>
/// Creates <see cref="ILogging"/>
/// </summary>
/// <param name="name">Name of the class that is requesting an <see cref="ILogging"/></param>
public static ILogging CreateLogger(string name)
{
ILogging logger = _logBuilders.LongLength switch
{
0 => EmptyLogger.StaticLogger,
1 => _logBuilders[0].CreateLogger(name),
_ => new WrapperLogger(name, _logBuilders)
};
Loggers.Add(logger);
return(logger);
}
/// <summary>
/// Publishes the app to the given directory using the current settings
/// </summary>
/// <param name="outputDirectory">Output path for the final published artifacts</param>
public void PublishTo(DirectoryPath outputDirectory)
{
OutputHandlers.Add(new PublishPageHandler());
Loggers.Add(new CakeLogger(Log));
var mgr = new CakePublishManager(this);
var responses = mgr.PublishApp(outputDirectory.MakeAbsolute(Environment).FullPath,
ForceBuild ? PublishBehaviour.CleanFirst : PublishBehaviour.DoNotBuild);
foreach (var r in responses)
{
Log.Information($"Handler finished: {r.Result} - {r.ResultMessage}");
}
}
/// <summary>
/// Adds a logger instance to the server
/// </summary>
/// <returns>The server configuration.</returns>
/// <param name="logger">The logger module to add.</param>
public ServerConfig AddLogger(ILogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (Loggers == null)
{
Loggers = new List <ILogger>();
}
Loggers.Add(logger);
return(this);
}
public ILogger CreateLogger(string categoryName)
{
if (Loggers.ContainsKey(categoryName))
{
return(Loggers[categoryName]);
}
else
{
ILogger customerLogger = new CustomLogger(LogLevel.Error,
this.CustomLoggerConfiguration);
Loggers.Add(categoryName, customerLogger);
return(customerLogger);
}
}
public Task <SqlMapper.GridReader> QueryMultipleAsync(string sql, object param = null, CommandType text = CommandType.Text)
{
Stopwatch watch = new Stopwatch();
watch.Start();
var list = Target.QueryMultipleAsync(sql, param, text);
watch.Stop();
Loggers.Add(new SessionLogger()
{
Sql = sql,
Param = param,
Time = DateTime.Now,
Text = "QueryMultipleAsync",
Watch = watch.ElapsedMilliseconds
});
return(list);
}
public Task <T> ExecuteScalarAsync <T>(string sql, object param = null, CommandType text = CommandType.Text)
{
Stopwatch watch = new Stopwatch();
watch.Start();
var task = Target.ExecuteScalarAsync <T>(sql, param, text);
watch.Stop();
Loggers.Add(new SessionLogger()
{
Sql = sql,
Param = param,
Time = DateTime.Now,
Text = "ExecuteScalarAsync",
Watch = watch.ElapsedMilliseconds
});
return(task);
}
public IDataReader ExecuteReader(string sql, object param = null, CommandType text = CommandType.Text)
{
Stopwatch watch = new Stopwatch();
watch.Start();
var datareader = Target.ExecuteReader(sql, param, text);
watch.Stop();
Loggers.Add(new SessionLogger()
{
Sql = sql,
Param = param,
Time = DateTime.Now,
Text = "ExecuteReader",
Watch = watch.ElapsedMilliseconds
});
return(datareader);
}
public Task <IEnumerable <dynamic> > QueryAsync(string sql, object param = null, CommandType text = CommandType.Text)
{
Stopwatch watch = new Stopwatch();
watch.Start();
var list = Target.QueryAsync(sql, param, text);
watch.Stop();
Loggers.Add(new SessionLogger()
{
Sql = sql,
Param = param,
Time = DateTime.Now,
Text = "QueryAsync",
Watch = watch.ElapsedMilliseconds
});
return(list);
}
/// <summary> /// Adds a new logger to the set /// </summary> /// <param name="logger">The logger to add</param> public void Put(Logger logger) => Loggers.Add(logger);
public static void Register(string publicKey, ILogger logger)
{
Loggers.Add(publicKey, logger);
}
public ClickTwicePackSettings WithLogger(IPublishLogger logger)
{
Loggers.Add(logger);
return(this);
}
/// <summary>
/// Adds a new logger which wishes to be notified whenever something needs to be logged.
/// </summary>
/// <param name="logger">The logger object.</param>
public static void AddLogger(ILogger logger)
{
Loggers.Add(logger);
}
