public static LogEventLevel ToSerilogLevel(this SyslogLevel level)
{
switch (level)
{
case SyslogLevel.Emergency:
return(LogEventLevel.Fatal);
case SyslogLevel.Alert:
return(LogEventLevel.Fatal);
case SyslogLevel.Critical:
return(LogEventLevel.Fatal);
case SyslogLevel.Error:
return(LogEventLevel.Error);
case SyslogLevel.Warning:
return(LogEventLevel.Warning);
case SyslogLevel.Notice:
return(LogEventLevel.Warning);
case SyslogLevel.Info:
return(LogEventLevel.Information);
case SyslogLevel.Debug:
return(LogEventLevel.Debug);
default:
throw new ArgumentOutOfRangeException(nameof(level), level, null);
}
}
static void WriteToLogger(ILogger logger, SyslogLevel level, string message)
{
switch (level)
{
case SyslogLevel.Emergency:
case SyslogLevel.Alert:
case SyslogLevel.Critical:
case SyslogLevel.Error:
logger.Error(message);
break;
case SyslogLevel.Warning:
case SyslogLevel.Notice:
logger.Warn(message);
break;
case SyslogLevel.Info:
logger.Info(message);
break;
case SyslogLevel.Debug:
logger.Debug(message);
break;
default:
throw new ArgumentOutOfRangeException(nameof(level), level, "Unknown log level");
}
}
private static SemanticLogLevel GetLogLevel(SyslogLevel level)
{
switch (level)
{
case SyslogLevel.Emergency:
return(SemanticLogLevel.Fatal);
case SyslogLevel.Alert:
return(SemanticLogLevel.Fatal);
case SyslogLevel.Critical:
return(SemanticLogLevel.Fatal);
case SyslogLevel.Error:
return(SemanticLogLevel.Error);
case SyslogLevel.Warning:
return(SemanticLogLevel.Warning);
case SyslogLevel.Notice:
return(SemanticLogLevel.Information);
case SyslogLevel.Info:
return(SemanticLogLevel.Information);
case SyslogLevel.Debug:
return(SemanticLogLevel.Debug);
default:
return(SemanticLogLevel.Debug);
}
}
public static LogLevel MapLogLevel(SyslogLevel lvl)
{
switch (lvl)
{
case SyslogLevel.Emergency:
return(LogLevel.Fatal);
case SyslogLevel.Alert:
return(LogLevel.Fatal);
case SyslogLevel.Critical:
return(LogLevel.Fatal);
case SyslogLevel.Error:
return(LogLevel.Error);
case SyslogLevel.Warning:
return(LogLevel.Warn);
case SyslogLevel.Notice:
return(LogLevel.Info);
case SyslogLevel.Info:
return(LogLevel.Info);
case SyslogLevel.Debug:
return(LogLevel.Debug);
}
return(LogLevel.Info);
}
/// <summary>
/// Instantiates a new LogMessage class instance.
/// </summary>
/// <param name="name">
/// The librdkafka client instance name.
/// </param>
/// <param name="level">
/// The log level (levels correspond to syslog(3)), lower is worse.
/// </param>
/// <param name="facility">
/// The facility (section of librdkafka code) that produced the message.
/// </param>
/// <param name="message">
/// The log message.
/// </param>
public LogMessage(string name, SyslogLevel level, string facility, string message)
{
Name = name;
Level = level;
Facility = facility;
Message = message;
}
/// <summary>
/// Convenience method to send an exception message to GrayLog.
/// </summary>
/// <param name="ex">The exception to log.</param>
/// <param name="level">The level to log the exception at.</param>
public void Send(Exception ex, SyslogLevel level = SyslogLevel.Error)
{
// Send exception:
if (ex != null)
{
this.Send(ex.Message, null, new { level = level }, ex);
}
}
public static Int32 FromSyslogLevel(SyslogLevel value)
{
Int32 rval;
if (FromSyslogLevel(value, out rval) == -1)
{
ThrowArgumentException(value);
}
return(rval);
}
private void LogCallback(IntPtr rk, SyslogLevel level, string fac, string buf)
{
// Ensure registered handlers are never called as a side-effect of Dispose/Finalize (prevents deadlocks in common scenarios).
// Note: kafkaHandle can be null if the callback is during construction (in that case, we want the delegate to run).
if (ownedKafkaHandle != null && ownedKafkaHandle.IsClosed)
{
return;
}
logHandler?.Invoke(new LogMessage(Util.Marshal.PtrToStringUTF8(Librdkafka.name(rk)), level, fac, buf));
}
/// <summary>
/// <see cref="LogLevel"/> に変換します。
/// </summary>
/// <param name="syslogLevel"></param>
/// <returns></returns>
public static LogLevel ToLogLevel(this SyslogLevel syslogLevel)
{
return(syslogLevel switch
{
SyslogLevel.Emergency => LogLevel.Critical,
SyslogLevel.Alert => LogLevel.Critical,
SyslogLevel.Critical => LogLevel.Critical,
SyslogLevel.Error => LogLevel.Error,
SyslogLevel.Warning => LogLevel.Warning,
SyslogLevel.Notice => LogLevel.Information,
SyslogLevel.Info => LogLevel.Information,
SyslogLevel.Debug => LogLevel.Debug,
_ => LogLevel.None,
});
private void LogCallback(IntPtr rk, SyslogLevel level, string fac, string buf)
{
if (kafkaHandle != null && kafkaHandle.IsClosed)
{
return;
}
try
{
// Ensure registered handlers are never called as a side-effect of Dispose/Finalize (prevents deadlocks in common scenarios).
// Note: kafkaHandle can be null if the callback is during construction (in that case the delegate should be called).
logHandler?.Invoke(new LogMessage(Util.Marshal.PtrToStringUTF8(Librdkafka.name(rk)), level, fac, buf));
}
catch (Exception)
{
// Eat any exception thrown by user log handler code.
}
}
private SyslogLevel GetLevel(PShell.psmethods.PSAlert.AlertType level)
{
SyslogLevel rtn = SyslogLevel.Information;
bool found = false;
int idx = 0;
int[] sidx = { 1, 2, 3, 4, 6 };
do
{
SyslogLevel lvl = (SyslogLevel)sidx[idx];
if (lvl.ToString() == level.ToString())
{
found = true;
rtn = lvl;
}
idx++;
} while (!found && idx < sidx.Length);
return(rtn);
}
private static string BuildMessage(SyslogLevel level, DateTime t, string machine, string source, long instanceid, string message)
{
var msg = new StringBuilder();
// PRI
var priority = 16 * 8 + (int)level;
msg.Append($"<{priority}>");
// HEADER::TIMESTAMP
msg.Append($"{_months[t.Month]} {t.Day:00} {t.Hour:00}:{t.Minute:00}:{t.Second:00} ");
// HEADER::HOSTNAME
msg.Append(machine.ToLower(CultureInfo.CurrentCulture).Replace(" ", "_"));
msg.Append(" ");
// MSG::TAG
msg.Append($"{source.Replace(' ', '_')}[{instanceid}]: ");
// MSG::CONTENT
// Have to clean out \r and \t, syslog will replace \n with " "
msg.Append(message.Replace("\r", "").Replace("\t", ""));
return(msg.ToString());
}
private static int ToSyslogLevel(Int32 value, out SyslogLevel rval)
{
throw new System.NotImplementedException();
}
public static Int32 FromSyslogLevel (SyslogLevel value)
{
Int32 rval;
if (FromSyslogLevel (value, out rval) == -1)
ThrowArgumentException (value);
return rval;
}
public static bool TryFromSyslogLevel (SyslogLevel value, out Int32 rval)
{
return FromSyslogLevel (value, out rval) == 0;
}
private static extern int FromSyslogLevel (SyslogLevel value, out Int32 rval);
public static bool TryToSyslogLevel (Int32 value, out SyslogLevel rval)
{
return ToSyslogLevel (value, out rval) == 0;
}
private static string BuildMessage(EntryWrittenEventArgs e, SyslogLevel level)
{
return(BuildMessage(level, e.Entry.TimeGenerated, e.Entry.MachineName, e.Entry.Source, e.Entry.InstanceId,
e.Entry.Message));
}
private static int FromSyslogLevel (SyslogLevel value, out Int32 rval)
{
throw new System.NotImplementedException();
}
public static void syslog (SyslogLevel level, string message)
{
int _level = UnixConvert.FromSyslogLevel (level);
sys_syslog (_level, GetSyslogMessage (message));
}
public static int setlogmask (SyslogLevel mask)
{
int _mask = UnixConvert.FromSyslogLevel (mask);
return sys_setlogmask (_mask);
}
public static bool TryFromSyslogLevel(SyslogLevel value, out Int32 rval)
{
return(FromSyslogLevel(value, out rval) == 0);
}
private static extern int FromSyslogLevel(SyslogLevel value, out Int32 rval);
private void ServerProc()
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
EndPoint remoteEP = new IPEndPoint(IPAddress.Any, IPEndPoint.MinPort);
char[] splitChars1 = new char[] { '>' };
char[] splitChars2 = new char[] { ' ' };
try {
byte[] buffer = new byte[4096];
socket.Bind(new IPEndPoint(IPAddress.Any, _port));
while (!_stop)
{
if (!socket.Poll(50000, SelectMode.SelectRead))
{
continue;
}
try {
int count = socket.ReceiveFrom(buffer, ref remoteEP);
string message = Encoding.ASCII.GetString(buffer, 0, count);
string[] parts = message.Split(splitChars1, 2);
SyslogFacility facility = SyslogFacility.User;
SyslogLevel level = SyslogLevel.Information;
if (parts.Length == 2)
{
int code = int.Parse(parts[0].TrimStart('<'), CultureInfo.InvariantCulture);
facility = (SyslogFacility)(code / 8);
level = (SyslogLevel)(code - ((int)facility * 8));
message = parts[1];
}
message = message.Substring(16);
parts = message.Split(splitChars2, 2);
if (parts.Length == 2)
{
message = parts[1];
}
switch (level)
{
case SyslogLevel.Emergency:
case SyslogLevel.Alert:
_log.Log(LogLevel.Fatal, message);
break;
case SyslogLevel.Critical:
case SyslogLevel.Error:
_log.Log(LogLevel.Error, message);
break;
case SyslogLevel.Warning:
_log.Log(LogLevel.Warn, message);
break;
case SyslogLevel.Debug:
_log.Log(LogLevel.Debug, message);
break;
case SyslogLevel.Notice:
case SyslogLevel.Information:
default:
_log.Log(LogLevel.Info, message);
break;
}
}
catch {
}
}
}
catch {
}
finally {
try {
socket.Close();
}
catch {
}
}
}
private static int ToSyslogLevel (Int32 value, out SyslogLevel rval)
{
throw new System.NotImplementedException();
}
public static void syslog (SyslogLevel level, string format,
params object[] parameters)
{
int _level = UnixConvert.FromSyslogLevel (level);
object[] _parameters = new object[checked(parameters.Length+2)];
_parameters [0] = _level;
_parameters [1] = format;
Array.Copy (parameters, 0, _parameters, 2, parameters.Length);
XPrintfFunctions.syslog (_parameters);
}
public static void syslog (SyslogFacility facility, SyslogLevel level, string message)
{
int _facility = UnixConvert.FromSyslogFacility (facility);
int _level = UnixConvert.FromSyslogLevel (level);
sys_syslog (_facility | _level, GetSyslogMessage (message));
}
/// <summary>
/// Convenience method to send an exception message to GrayLog.
/// </summary>
/// <param name="ex">The exception to log.</param>
/// <param name="level">The level to log the exception at.</param>
public void Send(Exception ex, SyslogLevel level = SyslogLevel.Error)
{
// Send exception:
if (ex != null) this.Send(ex.Message, null, new { level = level }, ex);
}
public string UnProcessedMessage(string Message, string Reason, SyslogLevel log)
{
return("");
}
private static extern int ToSyslogLevel (Int32 value, out SyslogLevel rval);
public static LogLevel ToLogLevel(this SyslogLevel syslogLevel) =>
syslogLevel switch
{
private static int FromSyslogLevel(SyslogLevel value, out Int32 rval)
{
throw new System.NotImplementedException();
}
private static extern int ToSyslogLevel(Int32 value, out SyslogLevel rval);
public static bool TryToSyslogLevel(Int32 value, out SyslogLevel rval)
{
return(ToSyslogLevel(value, out rval) == 0);
}
public static void WriteLine(Level level, string fmt, params object[] parm)
{
if ((int)level > (int)MaxLevel)
{
return;
}
lock (ConsoleLock) {
if (LogToFile)
{
try {
if (LogFile == null)
{
try {
File.Delete(String.Format("{0}.1", LogFilePath));
} catch {}
try {
File.Move(LogFilePath, String.Format("{0}.1", LogFilePath));
} catch {}
LogFile = new StreamWriter(new FileStream(LogFilePath, System.IO.FileMode.Append));
}
LogFile.WriteLine("[{0}] {1}", DateTime.Now, String.Format(fmt, parm));
}
catch {
LogToFile = false;
if (!LogToSyslog && !LogToConsole)
{
LogToSyslog = true; // we must log somewhere, right?
}
WriteLine(Level.Info, "Logging to file disabled due to errors while opening or writing to the log file.");
}
}
if (LogToSyslog)
{
if (IsLinux)
{
if (!SyslogReady)
{
Mono.Unix.Native.Syscall.openlog(Marshal.StringToHGlobalAuto(SyslogServiceName), SyslogOptions.LOG_PERROR | SyslogOptions.LOG_PID, SyslogFacility.LOG_DAEMON);
SyslogReady = true;
}
SyslogLevel slevel = SyslogLevel.LOG_DEBUG;
switch (level)
{
case Level.Important: slevel = SyslogLevel.LOG_INFO; break;
case Level.Error: slevel = SyslogLevel.LOG_ERR; break;
case Level.Warning: slevel = SyslogLevel.LOG_WARNING; break;
case Level.Info: slevel = SyslogLevel.LOG_INFO; break;
case Level.Debug: slevel = SyslogLevel.LOG_DEBUG; break;
}
Mono.Unix.Native.Syscall.syslog(SyslogFacility.LOG_DAEMON, slevel, String.Format(fmt, parm));
}
else
{
System.Diagnostics.EventLog.WriteEntry(SyslogServiceName, String.Format(fmt, parm));
}
}
if (LogToConsole && (!LogToSyslog || !IsLinux))
{
Console.WriteLine(fmt, parm);
}
}
if (AutoFlush)
{
Flush();
}
}
