static void Main(string[] args)
{
ILoggerFactory loggerFactory = new LoggerFactory();
ILogger logger = null;
logger = loggerFactory.GetLogger(LoggerType.Console);
logger.Log($"Doot doot, this should be a {nameof(ConsoleLogger)}. {logger.GetType()}");
logger = loggerFactory.GetLogger(LoggerType.File);
logger.Log($"Doot doot, this should be a {nameof(FileLogger)}. {logger.GetType()}");
}
/// <summary>
/// Gets the logger name (namespace, like PTV.Something.Controllers.SomeController) based on the generic ILogger{LoggerType} or non generic logger type name.
/// </summary>
/// <param name="logger"><see cref="Microsoft.Extensions.Logging.ILogger"/></param>
/// <returns>logger name</returns>
/// <exception cref="System.ArgumentNullException"><i>logger</i> is null reference</exception>
public static string GetLoggerName(this ILogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
var genericArgs = logger.GetType().GenericTypeArguments;
return(genericArgs.Any() ? genericArgs[0].FullName : logger.GetType().FullName);
}
public static void DoStuff(ILogger logger)
{
Console.WriteLine($"doing stuff with {logger.GetType().Name}");
var jobFactory = new JobFactory(logger);
int count = 50000;
int completed = 0;
double errorRate = 0.01;
var cancellation = new CancellationTokenSource();
Task.Run(async () =>
{
while (!cancellation.IsCancellationRequested)
{
Console.WriteLine($"Completed {completed}/{count} jobs");
await Task.Delay(1000, cancellation.Token);
}
}, cancellation.Token);
foreach (var job in jobFactory.GetJobsForExecution(count).AsParallel())
{
job.Execute(errorRate);
Interlocked.Increment(ref completed);
}
cancellation.Cancel();
}
private static object?GetActualLogger(ILogger logger)
{
var loggerType = logger.GetType();
var field = loggerType.GetField("_logger", BindingFlags.Instance | BindingFlags.NonPublic);
return(field?.GetValue(logger));
}
public static bool Initialized()
{
if (__log != null)
{
return(true);
}
lock (staticThreadLock)
{
if (_initialized)
{
return(__log != null);
}
_initialized = true;
}
Type log_type = null;
try
{
log_type = Type.GetType(__logType, true);
if (__log == null || __log.GetType() != log_type)
{
__log = (ILogger)Activator.CreateInstance(log_type);
__log.Info("Logging to {0} via {1}", __log, log_type.ToString());
}
}
catch (Exception e)
{
InitStandardLogging(e);
}
return(__log != null);
}
public void AddLogger(ILogger logger)
{
if (logger.GetType() != typeof(DebugLogger))
{
FLoggers.Add(logger);
}
}
public static void UnregisterLogger(ILogger logger)
{
if (logger != null)
{
Manager.UnregisterLogger(logger.GetType());
}
}
public GenerateLogsPageViewModel(LogGenerator generator, ILogger logger)
{
_generator = generator;
LoggerType = logger.GetType().Name;
GenerateLogs = new DelegateCommand(OnGenerateLogsExecuted);
}
public void Add(ILogger logger)
{
if (_loggers.Any(x => x.GetType() == logger.GetType()) == false)
{
_loggers.Add(logger);
}
}
private static LoggerAdapter TryGetLoggerAdapter(ILogger logger)
{
if (logger == null)
{
return(null);
}
if (logger is KissLog.AspNetCore.LoggerAdapter)
{
return(logger as KissLog.AspNetCore.LoggerAdapter);
}
FieldInfo loggerField = logger.GetType().GetField("_logger", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (loggerField == null)
{
return(null);
}
object loggerFieldValue = loggerField.GetValue(logger);
if (loggerFieldValue == null)
{
return(null);
}
PropertyInfo loggersProperty = loggerFieldValue.GetType().GetProperty("Loggers", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (loggersProperty == null)
{
return(null);
}
Array loggersArray = loggersProperty.GetValue(loggerFieldValue) as Array;
if (loggersArray == null)
{
return(null);
}
foreach (var loggerInformation in loggersArray)
{
if (loggerInformation == null)
{
continue;
}
PropertyInfo loggerProperty = loggerInformation.GetType().GetProperty("Logger", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (loggerProperty != null)
{
var loggerItem = loggerProperty.GetValue(loggerInformation);
if (loggerItem is KissLog.AspNetCore.LoggerAdapter loggerAdapter)
{
return(loggerAdapter);
}
}
}
return(null);
}
private static object[] AddLogContextData(this ILogger logger, object[] args)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
var now = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffffff");
// If this logger is an instance of Log.Logger get the context data from it, else get a new one
var traceContextData = (logger.GetType().Equals(typeof(Logger))) ? ((Logger)logger).TraceContext : new TraceContextData();
var argsLength = args != null ? args.Length : 0;
var newArgs = new object[argsLength + 3];
newArgs[argsLength] = now;
newArgs[argsLength + 1] = traceContextData.ProcessID;
newArgs[argsLength + 2] = traceContextData.TaskID;
if (argsLength > 0)
{
args.CopyTo(newArgs, 0);
}
return(newArgs);
}
public static void LogI(this ILogger logger, string message,
[CallerMemberName] string memberName = null,
[CallerFilePath] string filePath = null,
[CallerLineNumber] int lineNumber = 0,
params object[] args)
{
ILoggerExtensions.Log(logger.Information, logger.GetType(), message, args, memberName, filePath, lineNumber);
}
public void CreateLoggerTest()
{
LoggerFactory.SetLoggerType(typeof(ConsoleLogger));
ILogger logger = LoggerFactory.CreateLogger("TEST");
Assert.IsTrue(logger.GetType() == typeof(ConsoleLogger));
}
// Adds new log target
// It allows to add only unique types of loggers
private void AddLogger(ILogger logger)
{
if (!_loggers.Exists(x => x.GetType() == logger.GetType()))
{
_loggers.Add(logger);
//Console.WriteLine($"Added log target: {logger.GetType()}");
}
}
public static ILogger GetInternalLogger(this ILogger logger)
{
if (logger.GetType().IsGenericType)
{
logger = logger.GetType()
.GetField("_logger",
BindingFlags.Instance | BindingFlags.NonPublic)
?.GetValue(logger) as ILogger;
}
if (logger == null)
{
throw new Exception("Can't get internal logger!");
}
return(logger);
}
public static void LogW(this ILogger logger, string message,
[CallerMemberName] string memberName = null,
[CallerFilePath] string filePath = null,
[CallerLineNumber] int lineNumber = 0,
params object[] args)
{
Log(logger.LogWarning, logger.GetType(), message, args, memberName, filePath, lineNumber);
}
public void RegisterLogger(ILogger logger)
{
if (logger == null)
{
return;
}
Loggers.Add(logger.GetType(), logger);
}
private void LogForTryCatch(Exception e)
{
var loggerT = Logger.GetType();
Logger.WriteLog(LogLevel.Error, GetUser().CreateContainer(null, GetRequestId()), e,
(u, ex) => HttpContext.Request.Host + HttpContext.Request.Path, //url
loggerT.IsGenericType ? $"{loggerT.GetGenericArguments()[0].Name}.???.TryCatchLogAsync" : "BaseController.TryCatchLogAsync");
}
public void GetSourceLocation_Type_ReturnsUnknownIfAssemblyIsDynamic()
{
ILogger mockLogger = Mocks.StrictMock <ILogger>();
Mocks.ReplayAll();
Assert.AreEqual(CodeLocation.Unknown, DebugSymbolUtils.GetSourceLocation(mockLogger.GetType()));
}
static void Main(string[] args)
{
var providerType = GetTypeOfLoggingProviderFromConfigFile();
ILogger logger = LoggerProviderFactory.GetLoggingProvider(providerType);
logger.LogMessage("Hello Factory Method Design Pattern.");
Console.WriteLine(logger.GetType().Name);
}
public void TestGetLoggerByType()
{
ILogger logger = ApplicationLogging.CreateLogger(typeof(Program));
Type type = logger.GetType();
Assert.Equal("Logger", type.Name);
Assert.Equal("Microsoft.Extensions.Logging.Logger", type.FullName);
}
/// <summary>
/// Returns a new logger of the specified type
/// </summary>
/// <returns></returns>
public static ILogger getLogger()
{
//The various values for logDestination variable are {DB,EV,TL,FS}
if (logger == null)
{
logger = createLogger(logDestination);
}
else
{
//Check if the existing Logger is the type of the one set in the web.config
switch (logger.GetType().ToString())
{
case (TYPE_DBLOGGER):
if (!(logDestination == LOGGER_DBLOGGER))
{
return(createLogger(logDestination));
}
else
{
return(logger);
}
case (TYPE_EVENTLOGGER):
if (!(logDestination == LOGGER_EVENTLOGGER))
{
return(createLogger(logDestination));
}
else
{
return(logger);
}
case (TYPE_TRACELOGGER):
if (!(logDestination == LOGGER_TRACELOGGER))
{
return(createLogger(logDestination));
}
else
{
return(logger);
}
case (TYPE_FILELOGGER):
if (!(logDestination == LOGGER_FILELOGGER))
{
return(createLogger(logDestination));
}
else
{
return(logger);
}
default:
return(createLogger(logDestination));
}
}
return(logger);
}
public void GetXmlDocumentation_ReturnsNullIfAssemblyIsDynamic()
{
ILogger mockLogger = Mocks.StrictMock <ILogger>();
Mocks.ReplayAll();
// The mock logger's type can't possibly have documentation because it is dynamically generated.
Assert.IsNull(XmlDocumentationUtils.GetXmlDocumentation(mockLogger.GetType()));
}
/// <summary>
/// Add new Instance for logging
/// </summary>
/// <param name="logger"></param>
public static void AddInstance(ILogger logger)
{
Guard.IsNotNull(logger, nameof(logger));
if (Instances.All(x => x.GetType() != logger.GetType()))
{
Instances.Add(logger);
}
}
//public string logType(varName vName)
public string LogType(Action <string> vName)
{
var interfType = _logObject.GetType();
string myData;
myData = "Aditional info: Data type = " + interfType.ToString();
vName(myData);
return(interfType.ToString());
}
public Info Get()
{
return(new Info
{
Logger = logger.GetType().Name,
Provider = string.Format(GetType().Name),
Url = string.Format(request.Uri.ToString())
});
}
public static HttpResponseMessage Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
ILogger log
)
{
log.LogInformation("Function 2 - I am OK!");
return(req.CreateResponse(HttpStatusCode.OK, "pong;" + log.GetType().ToString()));
}
public string Trace()
{
var log = Logger as DLoggerTrace;
if (Logger is null)
{
return($"{Logger.GetType().Name}.{Name}");
}
return($"{log.Trace()}.{Name}");
}
public void Can_Resolve_Type()
{
Container ioc = new Container();
ioc.For <ILogger>().Use <SqlServerLogger>();
ILogger logger = ioc.Resolve <ILogger>();
Assert.AreEqual(typeof(SqlServerLogger), logger.GetType());
}
public static void Log(this ILogger logger, RequestProcessingEntity request)
{
if (logger.GetType() == typeof(Logger <Logger.RequestLogger>))
{
logger.Log(LogLevel.Information, new EventId(), request, null, (x, y) => "");
}
else
{
logger.LogInformation("Method: {0} Path: {1} Status code: {2}", request.Method, request.Path, request.StatusCode);
}
}
public static void Log(this ILogger logger, BadRequestEntity request)
{
if (logger.GetType() == typeof(Logger <Logger.RequestLogger>))
{
logger.Log(LogLevel.Error, new EventId(), request, null, (x, y) => "");
}
else
{
logger.LogError("Method: {0} Exeption: {1}", request.Method, request.Exeption);
}
}
/// <summary>
/// Adds the specified logger if it hasn't already been added. If
/// the specified logger is the current MultiTargetLogger it will not be added.
/// If the specified logger is a NullLoger it will not be added.
/// </summary>
/// <param name="logger"></param>
public void AddLogger(ILogger logger)
{
if (logger.IsNull)
{
return;
}
if (!_loggers.Contains(logger) && logger != this && _loggers.Where(l => l.GetType() == logger.GetType()).FirstOrDefault() == null)
{
_loggers.Add(logger);
}
}
internal static VLogger C2V(ILogger contract)
{
if (!System.Runtime.Remoting.RemotingServices.IsObjectOutOfAppDomain(contract) &&
(contract.GetType().Equals(typeof(LoggerV2C))))
{
return ((LoggerV2C)(contract)).GetSourceView();
}
else
{
return new LoggerC2V(contract);
}
}
/// <summary>
/// Initializes the logger and adds it to the list of loggers maintained by the engine
/// </summary>
/// <exception cref="LoggerException">Logger indicating it failed in a controlled way</exception>
/// <exception cref="InternalLoggerException">Logger threw arbitrary exception</exception>
private void RegisterLoggerInternal(ILogger logger, EventSource sourceForLogger, bool forwardingLogger)
{
try
{
if (logger is INodeLogger)
{
((INodeLogger)logger).Initialize(sourceForLogger, this.numberOfCpus);
}
else
{
logger.Initialize(sourceForLogger);
}
}
// Polite logger failure
catch (LoggerException)
{
throw;
}
catch (Exception e)
{
InternalLoggerException.Throw(e, null, "FatalErrorWhileInitializingLogger", false, logger.GetType().Name);
}
if (forwardingLogger)
{
if (forwardingLoggers == null)
{
forwardingLoggers = new ArrayList();
}
forwardingLoggers.Add(logger);
}
else
{
if (loggers == null)
{
loggers = new ArrayList();
}
loggers.Add(logger);
}
}
public void UnRegister(ILogger logger)
{
_loggers.Remove(logger.GetType().Name);
}
private static void EchoLogDescription(ILogger logger)
{
Console.WriteLine("ILogger Type: " + logger.GetType() + " Name: " + logger.Name);
}
/// <summary>
/// Adds a logger to the factory to the already defined loggers from the configuration
/// </summary>
/// <param name="logger">The logger to add to the loggerfactory</param>
public void AddLogger(ILogger logger)
{
LoggerFactory.AddLogger(logger.GetType().Name, logger);
}
/// <summary>
/// Initializes the logger and adds it to the list of loggers maintained by the engine.
/// This method is not expected to be called from multiple threads
/// </summary>
/// <exception cref="LoggerException">A logger exception thrown by a logger when its initialize call is made</exception>
/// <exception cref="InternalLoggerException">Any exceptions from initializing the logger which are not loggerExceptions are caught and wrapped in a InternalLoggerException</exception>
/// <exception cref="Exception">Any exception which is a ExceptionHandling.IsCriticalException will not be wrapped</exception>
private void InitializeLogger(ILogger logger, IEventSource sourceForLogger)
{
try
{
INodeLogger nodeLogger = logger as INodeLogger;
if (null != nodeLogger)
{
nodeLogger.Initialize(sourceForLogger, _maxCPUCount);
}
else
{
logger.Initialize(sourceForLogger);
}
}
catch (LoggerException)
{
throw;
}
catch (Exception e)
{
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
InternalLoggerException.Throw(e, null, "FatalErrorWhileInitializingLogger", true, logger.GetType().Name);
}
// Keep track of the loggers so they can be unregistered later on
_iloggerList.Add(logger);
}
/// <summary>
/// Shutdown an ILogger
/// Rethrow LoggerExceptions
/// Wrap all other exceptions in an InternalLoggerException
/// </summary>
/// <param name="logger">Logger to shutdown</param>
/// <exception cref="InternalLoggerException">Any exception comming from a logger during shutdown that is not a LoggerException is wrapped in an InternalLoggerException and thrown</exception>
/// <exception cref="LoggerException">Errors during logger shutdown may throw a LoggerException, in this case the exception is re-thrown</exception>
private void ShutdownLogger(ILogger logger)
{
try
{
if (logger != null)
{
logger.Shutdown();
}
}
catch (LoggerException)
{
throw;
}
catch (Exception e)
{
if (ExceptionHandling.IsCriticalException(e))
{
throw;
}
InternalLoggerException.Throw(e, null, "FatalErrorDuringLoggerShutdown", false, logger.GetType().Name);
}
}
public void Register(ILogger logger)
{
_loggers.Add(logger.GetType().Name, logger);
}
public void Add(ILogger logger)
{
if (_loggers.Any(x=>x.GetType() == logger.GetType()) == false)
_loggers.Add(logger);
}
