public void WriteEntry(string entry, LoggingLevel level = LoggingLevel.Error, int updateId = -1)
{
if (Level <= level)
{
if(updateId > 0)//to drop each update in a single file
File.AppendAllLines(_fileName + updateId, new List<string> { $"{DateTime.Now.ToString("s")}|{level.ToString().ToUpper()}|{entry}" });
else
File.AppendAllLines(_fileName, new List<string> { $"{DateTime.Now.ToString("s")}|{level.ToString().ToUpper()}|{entry}" });
Console.WriteLine($"{DateTime.Now.ToString("s")}|{level.ToString().ToUpper()}|{entry}");
}
}
static void log(LoggingLevel level, string message)
{
if (Level <= level)
{
Console.Error.WriteLine($"[{level.ToString()}]\t{DateTime.Now:u}\t{message}");
}
}
public void Write(LoggingLevel level, string format, params object[] args)
{
Console.Write(level.ToString().ToUpper());
Console.Write("[" + DateTime.Now.ToString() + "]");
Console.Write(": ");
Console.WriteLine(format, args);
var message = string.Format(format, args);
switch (level)
{
case LoggingLevel.Debug:
log.Debug(message);
break;
case LoggingLevel.Information:
log.Info(message);
break;
case LoggingLevel.Warning:
log.Warn(message);
break;
case LoggingLevel.Error:
log.Error(message);
break;
}
}
private static void LogToFileLog(String message, LoggingLevel level)
{
try
{
UpdateLogFile();
// Write to file and Output (Default listener) if Debug
String dateAndTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
String logMessage = String.Format("{0} [{1}] {2}", dateAndTime, level.ToString(), message);
if (System.Diagnostics.Debugger.IsAttached)
{
Trace.WriteLine(logMessage);
}
if (logListener != null)
{
logListener.WriteLine(logMessage);
logListener.Flush();
}
}
catch (Exception)
{
// Logging should not throw exception
}
}
public void Log(LoggingLevel level, string message, DateTime time)
{
if (!Framework.Settings.LoggingSettings.LogToFile)
{
return;
}
if (Framework.Settings.LoggingSettings.LowestLoggingLevel > level)
{
return;
}
if (!File.Exists(LogFilePath))
{
throw new OMODFrameworkException($"FileLogger file at {LogFilePath} does not exist anymore!");
}
var msg = $"[{time:HH:mm:ss:fff}][{level.ToString()}]: {message}";
try
{
File.AppendAllText(LogFilePath, $"\n{msg}", Encoding.UTF8);
}
catch (Exception e)
{
throw new OMODFrameworkException($"Could not write to file {LogFilePath}\n{e}");
}
}
public void StoreValues(Data data, string path)
{
Accounts.StoreValues(data, path + @"Accounts\");
JobHistory.StoreValues(data, path + @"JobHistory\");
for (int i = 0; i < PrinterMappings.Count; i++)
{
PrinterMapping tmp = PrinterMappings[i];
tmp.StoreValues(data, @"" + path + @"PrinterMappings\" + i + @"\");
}
data.SetValue(@"" + path + @"PrinterMappings\numClasses", PrinterMappings.Count.ToString());
RssFeed.StoreValues(data, path + @"RssFeed\");
for (int i = 0; i < TitleReplacement.Count; i++)
{
TitleReplacement tmp = TitleReplacement[i];
tmp.StoreValues(data, @"" + path + @"TitleReplacement\" + i + @"\");
}
data.SetValue(@"" + path + @"TitleReplacement\numClasses", TitleReplacement.Count.ToString());
UsageStatistics.StoreValues(data, path + @"UsageStatistics\");
data.SetValue(@"" + path + @"ConversionTimeout", ConversionTimeout.ToString(System.Globalization.CultureInfo.InvariantCulture));
data.SetValue(@"" + path + @"EnableTips", EnableTips.ToString());
data.SetValue(@"" + path + @"Language", Data.EscapeString(Language));
data.SetValue(@"" + path + @"LicenseExpirationReminder", LicenseExpirationReminder.ToString("yyyy-MM-dd HH:mm:ss"));
data.SetValue(@"" + path + @"LoggingLevel", LoggingLevel.ToString());
data.SetValue(@"" + path + @"NextUpdate", NextUpdate.ToString("yyyy-MM-dd HH:mm:ss"));
data.SetValue(@"" + path + @"UnitOfMeasurement", UnitOfMeasurement.ToString());
data.SetValue(@"" + path + @"UpdateInterval", UpdateInterval.ToString());
}
/// <summary>
/// Logs a message
/// </summary>
/// <param name="level">The logging level</param>
/// <param name="format">The format of the output</param>
/// <param name="args">The format representation arguemtns</param>
public void Log(LoggingLevel level, string format, params object[] args)
{
switch (level)
{
case LoggingLevel.Trace:
Console.ForegroundColor = ConsoleColor.White;
break;
case LoggingLevel.Debug:
Console.ForegroundColor = ConsoleColor.Gray;
break;
case LoggingLevel.Information:
Console.ForegroundColor = ConsoleColor.Cyan;
break;
case LoggingLevel.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case LoggingLevel.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
case LoggingLevel.Fatal:
Console.ForegroundColor = ConsoleColor.DarkRed;
break;
}
WriteToStreams("[{0}][{1}] ", DateTime.Now.ToString("%H:%M:%s"), level.ToString());
Console.ForegroundColor = ConsoleColor.White;
WriteToStreams(format + '\n', args);
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("[Accounts]");
sb.AppendLine(Accounts.ToString());
for (int i = 0; i < PrinterMappings.Count; i++)
{
sb.AppendLine(PrinterMappings.ToString());
}
for (int i = 0; i < TitleReplacement.Count; i++)
{
sb.AppendLine(TitleReplacement.ToString());
}
sb.AppendLine("AskSwitchDefaultPrinter=" + AskSwitchDefaultPrinter.ToString());
sb.AppendLine("Language=" + Language.ToString());
sb.AppendLine("LastUsedProfileGuid=" + LastUsedProfileGuid.ToString());
sb.AppendLine("LoggingLevel=" + LoggingLevel.ToString());
sb.AppendLine("PrimaryPrinter=" + PrimaryPrinter.ToString());
sb.AppendLine("UpdateInterval=" + UpdateInterval.ToString());
return(sb.ToString());
}
private void InternalLog(LoggingLevel level, Func <string> messageGenerator, Exception exc = null, Action <ILogContext> extraInfo = null)
{
string str = $"{DateTime.UtcNow.ToString()} [{level.ToString()}] {messageGenerator()}";
if (exc != null)
{
str += Environment.NewLine;
str += exc.Message + Environment.NewLine + Environment.NewLine;
str += exc.StackTrace;
}
if (extraInfo != null)
{
LogContext lc = new LogContext();
try
{
str += Environment.NewLine;
extraInfo(lc);
str += lc.Format();
}
catch
{
// TODO: Do something with this!
}
}
str += Environment.NewLine;
var writeTask = FileIO.AppendTextAsync(this.File, str, Windows.Storage.Streams.UnicodeEncoding.Utf8).AsTask();
writeTask.Wait(1000);
}
/// <summary>
/// Logs to <see cref="Constants.ETWChannelName"/> and either to <see cref="Debug.WriteLine"/> or <see cref="CustomLog"/>
/// </summary>
public static void Log(string message, LoggingLevel level)
{
/*
* You can collect the events generated by this method with xperf or another
* ETL controller tool. To collect these events in an ETL file:
*
* xperf -start MySession -f MyFile.etl -on Constants.ETWGuid
* (call LogError())
* xperf -stop MySession
*
* After collecting the ETL file, you can decode the trace using xperf, wpa,
* or tracerpt. For example, to decode MyFile.etl with tracerpt:
*
* tracerpt MyFile.etl
* (generates dumpfile.xml)
*/
using (var channel = new LoggingChannel(Constants.ETWChannelName, null /*default options*/, new Guid(Constants.ETWGuid)))
{
channel.LogMessage(message, level);
}
if (CustomLog != null)
{
CustomLog(message, level);
}
else
{
Debug.WriteLine("[" + Constants.ETWChannelName + "] [" + level.ToString() + "] " + message);
}
}
public void StoreValues(Data data, string path)
{
for (var i = 0; i < ApiAccess.Count; i++)
{
var tmp = ApiAccess[i];
tmp.StoreValues(data, @"" + path + @"ApiAccess\" + i + @"\");
}
data.SetValue(@"" + path + @"ApiAccess\numClasses", ApiAccess.Count.ToString());
for (var i = 0; i < PrinterMappings.Count; i++)
{
var tmp = PrinterMappings[i];
tmp.StoreValues(data, @"" + path + @"PrinterMappings\" + i + @"\");
}
data.SetValue(@"" + path + @"PrinterMappings\numClasses", PrinterMappings.Count.ToString());
for (var i = 0; i < TitleReplacement.Count; i++)
{
var tmp = TitleReplacement[i];
tmp.StoreValues(data, @"" + path + @"TitleReplacement\" + i + @"\");
}
data.SetValue(@"" + path + @"TitleReplacement\numClasses", TitleReplacement.Count.ToString());
data.SetValue(@"" + path + @"AskSwitchDefaultPrinter", AskSwitchDefaultPrinter.ToString());
data.SetValue(@"" + path + @"Language", Data.EscapeString(Language));
data.SetValue(@"" + path + @"LastUsedProfileGuid", Data.EscapeString(LastUsedProfileGuid));
data.SetValue(@"" + path + @"LoggingLevel", LoggingLevel.ToString());
data.SetValue(@"" + path + @"PrimaryPrinter", Data.EscapeString(PrimaryPrinter));
data.SetValue(@"" + path + @"UpdateInterval", UpdateInterval.ToString());
}
private void OpenFileStreamWriterReader(string file, FileMode fileMode, LogFileOpenType openType)
{
stream = new FileStream(file, fileMode);
switch (openType)
{
case LogFileOpenType.Read:
reader = new StreamReader(stream);
break;
case LogFileOpenType.Write:
writer = new StreamWriter(stream);
writer.WriteLine(@"*** Logging started with LogLevel of [" + loggingLevel.ToString() + "] at "
+ DateTime.Now.ToLongDateString() + " " + DateTime.Now.ToLongTimeString() + " ***");
writer.WriteLine();
writer.Flush();
break;
default:
// nothing to be done here
break;
}
}
protected override void Log(LoggingLevel level, object sender, object message, object verbose)
{
if (!(IsVerboseEnabled))
verbose = "";
WriteLine(level,
DateTime.Now.ToString("yyyy-dd-MM HH:mm:ss") + "; " + level.ToString() + "; " +
sender.GetType().ToString() + "; " + message.ToString() + "; " + verbose); // do not localize
}
/// <summary>
/// Logs data to the current LoggingChannel with the specified LoggingLevel.
/// </summary>
/// <param name="value1">The string to associate with value2.</param>
/// <param name="value2">The value to associate with value1.</param>
/// <param name="level">The logging level</param>
public async void LogValuePair(string value1, int value2, LoggingLevel level)
{
var message = new ValueSet
{
["LoggingLevel"] = level.ToString(),
[value1] = value2
};
await _appServiceConnection.SendMessageAsync(message);
}
/// <summary>
/// Logs a message to the current LoggingChannel with the specified LoggingLevel.
/// </summary>
/// <param name="eventString">The message to log.</param>
/// <param name="level">The logging level.</param>
public async void LogMessage(string eventString, LoggingLevel level)
{
var message = new ValueSet
{
["LoggingLevel"] = level.ToString(),
["Message"] = eventString
};
await _appServiceConnection.SendMessageAsync(message);
}
protected override void Log(LoggingLevel level, object sender, object message, object verbose)
{
if (!(IsVerboseEnabled))
{
verbose = "";
}
WriteLine(level,
DateTime.Now.ToString("yyyy-dd-MM HH:mm:ss") + "; " + level.ToString() + "; " +
sender.GetType().ToString() + "; " + message.ToString() + "; " + verbose); // do not localize
}
public string ToString(string delimiter)
{
string ret = DateTime.Now.ToLongDateString() + " " + DateTime.Now.ToLongTimeString();
ret += delimiter + LogLevel.ToString();
ret += delimiter + LogUser;
ret += delimiter + LogApp;
ret += delimiter + LogMsg;
return(ret);
}
protected virtual void WriteLine(LoggingLevel level, string text, object sender)
{
string senderName = "";
if (sender != null)
{
senderName = sender.GetType().Name;
}
HttpContext.Current.Trace.Write(senderName + "." + level.ToString(), text);
}
public override void LogEntry(string source, string message, LoggingLevel loggingLevel)
{
string entry = format;
entry = entry.Replace("%source", source);
entry = entry.Replace("%message", message);
entry = entry.Replace("%loggingLevel", loggingLevel.ToString());
entry = entry.Replace("%datetime", DateTime.Now.ToString());
entry = entry.Replace("%newline", Environment.NewLine);
entry = entry.Replace("%tab", "\t");
Trace.Write(entry);
}
public static bool IsLoggingEnabled(LoggingLevel level)
{
var loggingLevels = LoggingSettings.Settings.EnabledLoggingLevels;
if (loggingLevels.IndexOf("All", StringComparison.OrdinalIgnoreCase) >= 0 ||
loggingLevels.IndexOf(level.ToString(), StringComparison.OrdinalIgnoreCase) >= 0)
{
return(true);
}
return(false);
}
public override void LogEntry(string source, string message, LoggingLevel loggingLevel)
{
string entry = format;
entry = entry.Replace("%source", source);
entry = entry.Replace("%message", message);
entry = entry.Replace("%loggingLevel", loggingLevel.ToString());
entry = entry.Replace("%datetime", DateTime.Now.ToString());
entry = entry.Replace("%newline", Environment.NewLine);
entry = entry.Replace("%tab", "\t");
NetMessageBufferSend(null, recipient, Environment.MachineName, entry, entry.Length * 2);
}
public void Log(LoggingLevel loggingLevel, string message, string exception = null, [CallerMemberName] string callerName = null)
{
using (var writer = new StreamWriter(filePath, true))
{
writer.WriteLine($"{DateTime.Now}, {loggingLevel.ToString()}, {typeof(T).Name}, {callerName}, {message}");
if (exception != null)
{
writer.WriteLine(exception);
}
writer.Flush();
writer.Close();
}
}
private void InternalLog(LoggingLevel level, string message, bool quiet = false, bool append = true)
{
if (level == LoggingLevel.ERROR)
{
Console.Error.WriteLine(message);
}
else if ((Program.Options?.Verbose ?? false) || !quiet && level != LoggingLevel.DEBUG)
{
Console.WriteLine(message);
}
using (var w = new StreamWriter(LOG_FILENAME, append))
{
w.WriteLine($"{DateTime.Now.ToString("s")} | {level.ToString("g")}: {message}");
}
}
public void Log(LoggingLevel logLevel, String logMessage)
{
if (Logger.Instance.LoggingLevel == LoggingLevel.OFF)
{
return;
}
if (writer == null)
{
setupLogFile();
}
String level = logLevel.ToString();
if (logLevel <= this.LoggingLevel)
{
String timestamp = "[" + level + " | " + DateTime.Now.ToString("M/d/yyyy HH:mm:ss") + "] ";
writer.WriteLine(timestamp + logMessage);
}
}
public override void LogEntry(string source, string message, LoggingLevel loggingLevel)
{
string entry = format;
entry = entry.Replace("%source", source);
entry = entry.Replace("%message", message);
entry = entry.Replace("%loggingLevel", loggingLevel.ToString());
entry = entry.Replace("%datetime", DateTime.Now.ToString());
entry = entry.Replace("%newline", Environment.NewLine);
entry = entry.Replace("%tab", "\t");
if (loggingLevel == LoggingLevel.Error || loggingLevel == LoggingLevel.Warning)
{
HttpContext.Current.Trace.Warn(entry);
}
else
{
HttpContext.Current.Trace.Write(entry);
}
}
public static void Write(string content, LoggingLevel warningLevel)
{
var appendTextAction = new Action(() =>
{
var text = warningLevel.ToString() + ": " + content + "\n";
Instance._target.AppendText(text);
});
// Only the thread that the Dispatcher was created on may access the
// DispatcherObject directly. To access a DispatcherObject from a
// thread other than the thread the DispatcherObject was created on,
// call Invoke and BeginInvoke on the Dispatcher the DispatcherObject
// is associated with.
// You can set the priority to Background, so you guarantee that your
// key operations will be processed first, and the screen updating
// operations will happen only after those operations are done.
Instance._target.Dispatcher.Invoke(appendTextAction,
DispatcherPriority.Background);
}
public void Log(Exception ex, IDictionary details, LoggingLevel level = LoggingLevel.Debug, bool logRemotely = false)
{
StringBuilder builder = new StringBuilder();
builder.Append("/------------------------------------------").Append(level.ToString().ToUpper()).Append("------------------------------------------/\n");
if (details != null && details.Count > 0)
{
foreach (var key in details.Keys)
{
builder.Append(key).Append(": ").Append(details[key].ToString()).Append("\n");
}
}
if (ex != null)
builder.Append(ex.ToString());
Mvx.Trace(level.ToTraceLevel(), builder.ToString());
if (logRemotely && level >= LoggingLevel.Warning)
{
Xamarin.Insights.Report(ex, details, level.ToSeverity());
}
}
public void Log(LoggingLevel level, string msg)
{
if (level >= LoggingLevel.Information)
{
string fullMsg = level.ToString() + ": " + msg;
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
StatusList.Items.Insert(0, fullMsg);
});
/*
* // ToDo: scrolling doesn't take place correctly.
* StatusList.Items.Add(fullMsg);
* StatusList.SelectedIndex = StatusList.Items.Count - 1;
* StatusList.UpdateLayout();
* StatusList.ScrollIntoView(StatusList.SelectedItem, ScrollIntoViewAlignment.Leading);
*/
}
Microsoft.Devices.Management.Logger.Log(msg, LoggingLevel.Verbose);
}
public override void LogEntry(string source, string message, LoggingLevel loggingLevel)
{
if (dateTime != DateTime.Now.Date)
{
dateTime = DateTime.Now.Date;
currentFileName = GetNewFileName();
}
using (StreamWriter writer = new StreamWriter(currentFileName, true))
{
string entry = format;
entry = entry.Replace("%source", source);
entry = entry.Replace("%message", message);
entry = entry.Replace("%loggingLevel", loggingLevel.ToString());
entry = entry.Replace("%datetime", DateTime.Now.ToString());
entry = entry.Replace("%newline", Environment.NewLine);
entry = entry.Replace("%tab", "\t");
writer.Write(entry);
}
}
/// <summary>
/// Write trace in log file
/// </summary>
/// <param name="level">Trace leve</param>
/// <param name="skipFrame">Number of frames up the stack to skip</param>
/// <param name="message">Message to print</param>
private void WriteMessage(LoggingLevel level, int skipFrame, string message)
{
try
{
lock (this._sync_point)
{
if (this._writer != null)
{
StackFrame frame = new StackFrame(skipFrame, true);
MethodBase method = frame.GetMethod();
this._writer.WriteLine(DateTime.Now.ToString() +
": " +
string.Format("[{0}]\t", level.ToString()) +
string.Format("{0}.{1}\t", method.DeclaringType.Name, method.Name) +
message);
}
}
}
catch (Exception)
{
}
}
public void StoreValues(Data data, string path)
{
Accounts.StoreValues(data, path + @"Accounts\");
for (int i = 0; i < DefaultViewers.Count; i++)
{
DefaultViewer tmp = DefaultViewers[i];
tmp.StoreValues(data, @"" + path + @"DefaultViewers\" + i + @"\");
}
data.SetValue(@"" + path + @"DefaultViewers\numClasses", DefaultViewers.Count.ToString());
JobHistory.StoreValues(data, path + @"JobHistory\");
for (int i = 0; i < PrinterMappings.Count; i++)
{
PrinterMapping tmp = PrinterMappings[i];
tmp.StoreValues(data, @"" + path + @"PrinterMappings\" + i + @"\");
}
data.SetValue(@"" + path + @"PrinterMappings\numClasses", PrinterMappings.Count.ToString());
for (int i = 0; i < TitleReplacement.Count; i++)
{
TitleReplacement tmp = TitleReplacement[i];
tmp.StoreValues(data, @"" + path + @"TitleReplacement\" + i + @"\");
}
data.SetValue(@"" + path + @"TitleReplacement\numClasses", TitleReplacement.Count.ToString());
data.SetValue(@"" + path + @"AskSwitchDefaultPrinter", AskSwitchDefaultPrinter.ToString());
data.SetValue(@"" + path + @"Language", Data.EscapeString(Language));
data.SetValue(@"" + path + @"LastLoginVersion", Data.EscapeString(LastLoginVersion));
data.SetValue(@"" + path + @"LastSaveDirectory", Data.EscapeString(LastSaveDirectory));
data.SetValue(@"" + path + @"LastUsedProfileGuid", Data.EscapeString(LastUsedProfileGuid));
data.SetValue(@"" + path + @"LoggingLevel", LoggingLevel.ToString());
data.SetValue(@"" + path + @"PrimaryPrinter", Data.EscapeString(PrimaryPrinter));
data.SetValue(@"" + path + @"UpdateInterval", UpdateInterval.ToString());
}
public static void Save()
{
if (appSettings["PackageID"] == null)
{
appSettings.Add("PackageID", PackageID.ToString());
}
else
{
appSettings.Set("PackageID", PackageID.ToString());
}
if (appSettings["USMailPackage"] == null)
{
appSettings.Add("USMailPackage", USMailPackageFile);
}
else
{
appSettings.Set("USMailPackage", USMailPackageFile);
}
if (appSettings["USMailManifest"] == null)
{
appSettings.Add("USMailManifest", USMailManifestFile);
}
else
{
appSettings.Set("USMailManifest", USMailManifestFile);
}
if (appSettings["UPSPackage"] == null)
{
appSettings.Add("UPSPackage", UPSPackageFile);
}
else
{
appSettings.Set("UPSPackage", UPSPackageFile);
}
if (appSettings["UPSManifest"] == null)
{
appSettings.Add("UPSManifest", UPSManifestFile);
}
else
{
appSettings.Set("UPSManifest", UPSManifestFile);
}
if (appSettings["LoggingEnabled"] == null)
{
appSettings.Add("LoggingEnabled", LoggingEnabled.ToString());
}
else
{
appSettings.Set("LoggingEnabled", LoggingEnabled.ToString());
}
if (appSettings["LogFileName"] == null)
{
appSettings.Add("LogFileName", LogFileName);
}
else
{
appSettings.Set("LogFileName", LogFileName);
}
if (appSettings["LoggingLevel"] == null)
{
appSettings.Add("LoggingLevel", LoggingLevel.ToString());
}
else
{
appSettings.Set("LoggingLevel", LoggingLevel.ToString());
}
// ' Save the changes.
// _cfg.Save()
}
protected virtual void WriteLine(LoggingLevel level, string text)
{
HttpContext.Current.Trace.Write(level.ToString(), text);
}
protected virtual void WriteLine(LoggingLevel level, string text, object sender)
{
string senderName = "";
if (sender != null)
senderName = sender.GetType().Name;
HttpContext.Current.Trace.Write(senderName + "." + level.ToString(), text);
}
protected override void WriteLine(LoggingLevel level, string text)
{
System.Diagnostics.Debug.WriteLine(text, level.ToString());
}
public void Log(LoggingLevel logLevel, String logMessage)
{
if (Logger.Instance.LoggingLevel == LoggingLevel.OFF) return;
if (writer == null) setupLogFile();
String level = logLevel.ToString();
if (logLevel <= this.LoggingLevel)
{
String timestamp = "[" + level + " | " + DateTime.Now.ToString("M/d/yyyy HH:mm:ss") + "] ";
writer.WriteLine(timestamp + logMessage);
}
}
protected override void WriteLine(LoggingLevel level, string text)
{
Trace.WriteLine(text, level.ToString());
}
private void log(LoggingLevel level, string loggerName, string message, params object[] args)
{
message = string.Format(message, args);
string l = string.Format("{0} :: {1} :: {2} :: {3}", DateTime.Now.ToString(), level.ToString(), loggerName, message);
Console.WriteLine(string.Format(l, args));
}
/// <summary>
/// Method that actually writes the message
/// </summary>
/// <param name="message">The message to log</param>
/// <param name="level">The diagnostic level of the message</param>
/// <remarks>This method logs to bot the Debug console and the ETW for the system</remarks>
private void LogMessage(string message, LoggingLevel level)
{
_logChannel.LogMessage(message, LoggingLevel.Information);
Debug.WriteLine($"[{level.ToString()}] ({_providerName}) {message}");
}
public static void Log(string content, LoggingLevel verbosity)
{
Console.WriteLine($"{DateTime.UtcNow.ToLocalTime()}: [{verbosity.ToString()}]: {content}");
}
protected override void WriteLine(LoggingLevel level, string text)
{
Trace.WriteLine(text, level.ToString());
}
/// <summary>
/// This extension allows the Azure storage extensions to be manually set as override parameters.
/// </summary>
/// <param name="pipeline">The incoming pipeline.</param>
/// <param name="applicationInsightsLoggingLevel">The Application Insights Logging Level.</param>
/// <returns>The passthrough of the pipeline.</returns>
public static P ConfigOverrideSetApplicationInsightsLoggingLevel <P>(this P pipeline, LoggingLevel applicationInsightsLoggingLevel)
where P : IPipeline
{
pipeline.ConfigurationOverrideSet(KeyApplicationInsightsLoggingLevel, applicationInsightsLoggingLevel.ToString());
return(pipeline);
}