public WebSocket(DiscordWSClient client)
{
_client = client;
_logLevel = client.Config.LogLevel;
_loginTimeout = client.Config.ConnectionTimeout;
_cancelToken = new CancellationToken(true);
_connectedEvent = new ManualResetEventSlim(false);
_engine = new WebSocketSharpEngine(this, client.Config);
_engine.BinaryMessage += (s, e) =>
{
using (var compressed = new MemoryStream(e.Data, 2, e.Data.Length - 2))
using (var decompressed = new MemoryStream())
{
using (var zlib = new DeflateStream(compressed, CompressionMode.Decompress))
zlib.CopyTo(decompressed);
decompressed.Position = 0;
using (var reader = new StreamReader(decompressed))
ProcessMessage(reader.ReadToEnd()).Wait();
}
};
_engine.TextMessage += (s, e) =>
{
/*await*/ ProcessMessage(e.Message).Wait();
};
}
/// <summary>
/// Logs a single runtime message.
/// </summary>
/// <param name="message">message to log.</param>
/// <param name="severity">type of the message.</param>
internal static void Log(String message, LogMessageSeverity severity = LogMessageSeverity.Information)
{
// Choose the right style for provided severity.
string severityCharacter = "?";
switch (severity)
{
case LogMessageSeverity.Success:
Console.ForegroundColor = ConsoleColor.Green;
severityCharacter = "+";
break;
case LogMessageSeverity.Error:
Console.ForegroundColor = ConsoleColor.Red;
severityCharacter = "-";
break;
case LogMessageSeverity.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
severityCharacter = "?";
break;
default:
Console.ForegroundColor = ConsoleColor.White;
severityCharacter = "*";
break;
}
// Show the message.
Console.WriteLine("[" + severityCharacter + "] " + message);
}
public WebSocket(DiscordWSClient client)
{
_client = client;
_logLevel = client.Config.LogLevel;
_loginTimeout = client.Config.ConnectionTimeout;
_cancelToken = new CancellationToken(true);
_connectedEvent = new ManualResetEventSlim(false);
_engine = new WebSocketSharpEngine(this, client.Config);
_engine.BinaryMessage += (s, e) =>
{
using (var compressed = new MemoryStream(e.Data, 2, e.Data.Length - 2))
using (var decompressed = new MemoryStream())
{
using (var zlib = new DeflateStream(compressed, CompressionMode.Decompress))
zlib.CopyTo(decompressed);
decompressed.Position = 0;
using (var reader = new StreamReader(decompressed))
ProcessMessage(reader.ReadToEnd()).Wait();
}
};
_engine.TextMessage += (s, e) =>
{
/*await*/ ProcessMessage(e.Message).Wait();
};
}
public MessageLoggedEventArgs(string source, LogMessageSeverity severity, string message, Exception exception = null)
{
Source = source ?? throw new ArgumentNullException(nameof(source));
Severity = severity;
Message = message;
Exception = exception;
}
internal void RaiseOnLog(LogMessageSeverity severity, string message)
{
if (LogMessage != null)
{
LogMessage(this, new LogMessageEventArgs(severity, LogMessageSource.Unknown, message));
}
}
/// <summary>
/// Optimized deserialization of a LogMessagePacket based on the current packet definition
/// </summary>
public new void ReadFieldsFast(IFieldReader reader)
{
base.ReadFieldsFast(reader);
m_ID = reader.ReadGuid();
m_Caption = reader.ReadString();
m_Severity = (LogMessageSeverity)reader.ReadInt32();
m_LogSystem = reader.ReadString();
m_CategoryName = reader.ReadString();
m_UserName = reader.ReadString();
m_Description = reader.ReadString();
m_Details = reader.ReadString();
m_ThreadIndex = reader.ReadInt32();
m_ThreadId = reader.ReadInt32();
m_MethodName = reader.ReadString();
m_ClassName = reader.ReadString();
m_FileName = reader.ReadString();
m_LineNumber = reader.ReadInt32();
string[] typeNames = reader.ReadStringArray();
string[] messages = reader.ReadStringArray();
string[] sources = reader.ReadStringArray();
string[] stackTraces = reader.ReadStringArray();
Guid applicationUserId = reader.ReadGuid();
if (m_ThreadIndex == 0)
{
m_ThreadIndex = m_ThreadId; // Zero isn't legal, so it must not have had it. Fall back to ThreadId.
}
if (applicationUserId != Guid.Empty)
{
ApplicationUser applicationUser;
m_SessionPacketCache.Users.TryGetValue(applicationUserId, out applicationUser);
UserPacket = applicationUser.Packet;
}
//these are supposed to be parallel arrays - assume they're all the same size.
int arrayLength = typeNames.GetLength(0);
var exceptions = new IExceptionInfo[arrayLength]; // local holder to build it up
IExceptionInfo lastException = null;
for (int i = 0; i < arrayLength; i++)
{
IExceptionInfo exception = new ExceptionInfoPacket()
{
TypeName = typeNames[i],
Message = messages[i],
Source = sources[i],
StackTrace = stackTraces[i],
};
exceptions[i] = exception;
if (lastException != null)
{
((ExceptionInfoPacket)lastException).InnerException = exception; //we are the inner exception to our parent.
}
lastException = exception;
}
m_ExceptionChain = exceptions; // Set the rehydrated ExceptionInfo[] array property
}
/// <summary>
/// A helper method to translate an NLog's log event level into a Loupe log message severity.
/// </summary>
/// <param name="level"></param>
/// <returns></returns>
private static LogMessageSeverity GetSeverityLevel(LogLevel level)
{
LogMessageSeverity severity = LogMessageSeverity.None;
// Check from most-frequent first, but round any unrecognized levels down to the best Loupe severity match.
if (level < LogLevel.Info)
{
severity = LogMessageSeverity.Verbose;
}
else if (level < LogLevel.Warn)
{
severity = LogMessageSeverity.Information;
}
else if (level < LogLevel.Error)
{
severity = LogMessageSeverity.Warning;
}
else if (level < LogLevel.Fatal)
{
severity = LogMessageSeverity.Error;
}
else if (level < LogLevel.Off)
{
severity = LogMessageSeverity.Critical;
}
return(severity);
}
public LogMessage(String message, LogMessageType type, LogMessageSeverity severity, Exception exception)
{
Message = message;
Type = type;
Severity = severity;
Exception = exception;
}
internal void RaiseOnLog(LogMessageSeverity severity, LogMessageSource source, string message)
{
if (LogMessage != null)
{
RaiseEvent(nameof(LogMessage), () => LogMessage(this, new LogMessageEventArgs(severity, source, message)));
}
}
/// <summary>
/// Create a new sessions event arguments container
/// </summary>
/// <param name="newSessions"></param>
/// <param name="warningSessions"></param>
/// <param name="errorSessions"></param>
/// <param name="criticalSessions"></param>
/// <param name="maxSeverity"></param>
public NewSessionsEventArgs(int newSessions, int warningSessions, int errorSessions, int criticalSessions, LogMessageSeverity maxSeverity)
{
NewSessions = newSessions;
WarningSessions = warningSessions;
ErrorSessions = errorSessions;
CriticalSessions = criticalSessions;
MaxSeverity = maxSeverity;
}
/// <summary>
/// Write the provided logging event to the central Gibraltar log.
/// </summary>
/// <remarks>
/// <para>The central Gibraltar logging class (Log) makes common decisions about when to write out logging information
/// and where to write it out, therefore not all Log4Net logging events may be chosen to be permanently recorded</para>
/// <para>Required as part of the Log4Net IAppender interface implementation.</para></remarks>
/// <param name="loggingEvent">The individual LoggingEvent to be appended.</param>
protected override void Append(LoggingEvent loggingEvent)
{
// We shouldn't need a lock in this method because we don't access any of our member variables here,
// and we don't need a recursion-guard because we don't send our own log events through log4net.
// But we do need to first make sure the information we need is available from the LoggingEvent.
// If it hasn't had any Fix flags set then we should be clear to access them without doing a Fix.
const FixFlags ourFixFlags = FixFlags.Message | FixFlags.LocationInfo // | FixFlags.UserName
| FixFlags.Identity | FixFlags.Exception;
FixFlags fixedFlags = loggingEvent.Fix;
if (fixedFlags != FixFlags.None)
{
// Hmmm, someone already did a Fix on this LoggingEvent, which apparently locks other values from
// being updated upon reference. So we need to make sure the ones we need are also "fixed".
// But don't do this if the flags are None because we don't want to lock the loggingEvent against
// being updated by other references if it isn't already.
// ToDo: Find out if this is actually necessary or if we are guaranteed to get our own LoggingEvent
// independent of any other appender. It seems odd that appenders could break each other this way.
FixFlags neededFlags = ourFixFlags & ~fixedFlags; // What we need which isn't already fixed
if (neededFlags != FixFlags.None)
{
// Uh-oh, there's something we do need to have "fixed"
loggingEvent.Fix = ourFixFlags; // should we set both (ourFixFlags | FixFlags.Partial) ?
// Flags that were already set are ignored in the new value, they can't change back to 0.
}
}
LocationInfo locationInfo = loggingEvent.LocationInformation;
IMessageSourceProvider messageSource = new LogMessageSource(locationInfo); // Wrap it with our converter
Exception exception = loggingEvent.ExceptionObject;
string loggerName = loggingEvent.LoggerName;
string message = Layout != null?RenderLoggingEvent(loggingEvent) : loggingEvent.RenderedMessage;
string userName = loggingEvent.Identity;
if (string.IsNullOrEmpty(userName))
{
// No thread-specific impersonating user, we'll just get the invariant process username later;
userName = null;
}
// This is a slight hack. We get our repository from the first LoggingEvent we see after a config update
// and use it to update our thresholds configuration. We are assuming each instance of an appender is
// associated with only one repository (but might in general be attached to multiple loggers).
// Notice that GibraltarMessageSeverity() will get the lock for access to our threshold config member variables.
LogMessageSeverity severity = GibraltarMessageSeverity(loggingEvent.Level, loggingEvent.Repository);
if (severity != LogMessageSeverity.None) // Filter out severities less than configured Verbose threshold
{
// We have a real event message. Log it to the central Gibraltar queue, tagged as from Log4Net
Log.Write(severity, "Log4Net", messageSource, userName, exception, LogWriteMode.Queued, null, loggerName, null, message);
}
}
private static void BroadcastMessage(LogMessageSeverity messageSeverity, string message, Exception associatedException)
{
#if !RELEASE
string stdoutMessage = "Logger: "
+ (messageSeverity == LogMessageSeverity.Standard ? String.Empty : "[" + messageSeverity + "] ")
+ message
+ (associatedException == null ? String.Empty : " Ex: " + associatedException.GetAllMessages(true));
Debug.WriteLine(stdoutMessage);
#endif
}
public override void WriteMessage(LogMessageSeverity messageSeverity, string message, Exception associatedException, string callerMemberName, string callerFilePath, int callerLineNumber)
{
lock (InstanceMutationLock) {
if (suppressMessageCounter > 0U && messageSeverity != LogMessageSeverity.Fatal)
{
++discardCounter;
return;
}
}
base.WriteMessage(messageSeverity, message, associatedException, callerMemberName, callerFilePath, callerLineNumber);
}
public BasicLogMessage(LogMessageSeverity severity, LogWriteMode writeMode, string logSystem, string categoryName,
int skipFrames, Exception exception, bool attributeToException, string caption, string description, params object[] args)
: base(severity, logSystem, categoryName, skipFrames + 1, false, attributeToException, exception)
{
WriteMode = writeMode;
Exception = exception;
DetailsXml = null;
Caption = caption;
Description = description;
MessageArgs = args;
}
public SimpleLogMessage(LogMessageSeverity severity, LogWriteMode writeMode, string logSystem, string categoryName,
int skipFrames, Exception exception, string message, params object[] args)
: base(severity, logSystem, categoryName, skipFrames + 1, false, false, null)
{
WriteMode = writeMode;
Exception = exception;
DetailsXml = null;
Caption = null; // null signals that we need to split the description to find the caption when publishing.
Description = message;
MessageArgs = args;
}
public DetailLogMessage(LogMessageSeverity severity, LogWriteMode writeMode, string logSystem, string categoryName,
int skipFrames, Exception exception, bool attributeToException, string detailsXml, string caption,
string description, params object[] args)
: base(severity, logSystem, categoryName, skipFrames + 1, false, attributeToException, exception)
{
WriteMode = writeMode;
Exception = exception;
DetailsXml = detailsXml;
Caption = caption; // Allow null, or should we force it to string.Empty? Null will split it within Description.
Description = description;
MessageArgs = args;
}
internal LocalLogMessage(LogMessageSeverity severity, LogWriteMode writeMode, string logSystem, string categoryName,
int skipFrames, Exception exception, bool attributeToException, string detailsXml, string caption,
string description, params object[] args)
: base(severity, logSystem, categoryName, skipFrames + 1, true, attributeToException, exception)
{
WriteMode = writeMode;
Exception = exception;
DetailsXml = detailsXml;
Caption = caption; // Allow null, which will split it within Description.
Description = description;
MessageArgs = args;
}
/// <summary>
/// Write the log event received by this Target into the Loupe central log.
/// </summary>
/// <param name="logEvent">The LogEventInfo for a log event.</param>
protected override void Write(LogEventInfo logEvent)
{
if (logEvent == null)
{
return;
}
LogMessageSeverity severity = GetSeverityLevel(logEvent.Level);
IMessageSourceProvider sourceProvider = new NLogSourceProvider(logEvent);
string category = GetCategory(logEvent);
Exception exception = GetException(logEvent);
// By passing null for caption it will automatically get the caption from the first line of the formatted message.
Gibraltar.Agent.Log.Write(severity, ThisLogSystem, sourceProvider, null, exception, LogWriteMode.Queued,
null, category, null, logEvent.FormattedMessage);
}
private event NotificationEventHandler m_NotificationEvent; // LOCKED BY QUEUELOCK (subscribed only through property)
/// <summary>
/// Create a Notifier looking for a given minimum LogMessageSeverity.
/// </summary>
/// <param name="minimumSeverity">The minimum LogMessageSeverity to look for.</param>
/// <param name="notifierName">A name for this notifier (may be null for generic).</param>
public Notifier(LogMessageSeverity minimumSeverity, string notifierName) // Note: Add config, etc?
{
m_MessageQueue = new Queue <LogMessagePacket>(50); // a more or less arbitrary initial size.
m_MinimumSeverity = minimumSeverity;
m_MinimumWaitNextNotify = TimeSpan.Zero; // No delay by default.
m_MessageDispatchThreadFailed = true; // We'll need to start one if we get a packet we care about.
if (string.IsNullOrEmpty(notifierName))
{
m_NotifierName = string.Empty;
m_NotifierCategoryName = NotifierCategoryBase;
}
else
{
m_NotifierName = notifierName;
m_NotifierCategoryName = string.Format("{0}.{1}", NotifierCategoryBase, notifierName);
}
}
private async void TryWriteLogLine(string message, LogMessageSeverity severity)
{
if (_logFileStream == null)
{
return;
}
message = FormatMessage(message, severity);
try
{
await _taskQueue.Enqueue(() => _logFileStream.WriteLineAsync(message));
}
catch
{
// ignore
}
}
protected LogMessageBase(LogMessageSeverity severity, string logSystem, string categoryName, int skipFrames, bool localOrigin, bool attributeToException, Exception exception)
{
m_Severity = severity;
m_LogSystem = logSystem;
m_CategoryName = categoryName;
if (attributeToException && (ReferenceEquals(exception, null) == false))
{
//try to use the exception as the source provider..
var exceptionSourceProvider = new ExceptionSourceProvider(exception);
if (string.IsNullOrEmpty(exceptionSourceProvider.ClassName) == false)
{
//yep, we found something.
m_MessageSourceProvider = exceptionSourceProvider;
}
}
m_MessageSourceProvider = m_MessageSourceProvider ?? new MessageSourceProvider(skipFrames + 1, localOrigin);
}
public void WriteLog(LogMessageSeverity severity, string message)
{
if (!this.logLevel.HasValue || (int)severity >= (int)this.logLevel.Value)
{
MessageSeverity mappedSeverity = MessageSeverity.Information;
switch (severity)
{
case LogMessageSeverity.Debug: { mappedSeverity = MessageSeverity.Debug; break; }
case LogMessageSeverity.Information: { mappedSeverity = MessageSeverity.Information; break; }
case LogMessageSeverity.Warning: { mappedSeverity = MessageSeverity.Warning; break; }
case LogMessageSeverity.Error: { mappedSeverity = MessageSeverity.Error; break; }
}
this.Write(mappedSeverity, message);
}
}
public WebSocket(DiscordSimpleClient client)
{
_client = client;
_logLevel = client.Config.LogLevel;
_loginTimeout = client.Config.ConnectionTimeout;
_cancelToken = new CancellationToken(true);
_connectedEvent = new ManualResetEventSlim(false);
#if DNXCORE50
_engine = new BuiltInWebSocketEngine(client.Config.WebSocketInterval);
#else
_engine = new WSSharpWebSocketEngine(this, client.Config.UserAgent, client.Config.WebSocketInterval);
#endif
_engine.ProcessMessage += async (s, e) =>
{
if (_logLevel >= LogMessageSeverity.Debug)
RaiseOnLog(LogMessageSeverity.Debug, $"In: " + e.Message);
await ProcessMessage(e.Message);
};
}
internal NotificationEventArgs(ILogMessage[] messages, TimeSpan defaultMinWait)
{
MinimumNotificationDelay = defaultMinWait;
Messages = messages;
TopSeverity = LogMessageSeverity.Verbose;
foreach (ILogMessage message in messages)
{
if (message == null)
{
continue;
}
TotalCount++;
LogMessageSeverity severity = message.Severity;
if (severity < TopSeverity) // Severity compares in reverse, Critical = 1, Verbose = 16.
{
TopSeverity = severity; // Remember the new top severity.
}
switch (severity)
{
case LogMessageSeverity.Critical:
CriticalCount++;
break;
case LogMessageSeverity.Error:
ErrorCount++;
break;
case LogMessageSeverity.Warning:
WarningCount++;
break;
}
if (message.HasException)
{
ExceptionCount++;
}
}
}
private MessageSourceProvider m_EventErrorSourceProvider; // Not locked. Single-threaded use inside the dispatch loop only.
/// <summary>
/// Create a Notifier looking for a given minimum LogMessageSeverity.
/// </summary>
/// <param name="publisher"></param>
/// <param name="minimumSeverity">The minimum LogMessageSeverity to look for.</param>
/// <param name="notifierName">A name for this notifier (may be null for generic).</param>
/// <param name="groupMessages">True to delay and group messages together for more efficient processing</param>
public Notifier(Publisher publisher, LogMessageSeverity minimumSeverity, string notifierName, bool groupMessages = true)
{
m_Publisher = publisher;
m_MessageQueue = new Queue <LogMessagePacket>(50); // a more or less arbitrary initial size.
m_MinimumSeverity = minimumSeverity;
m_GroupMessages = groupMessages;
m_MinimumWaitNextNotify = TimeSpan.Zero; // No delay by default.
m_MessageDispatchThreadFailed = true; // We'll need to start one if we get a packet we care about.
if (string.IsNullOrEmpty(notifierName))
{
m_NotifierName = string.Empty;
m_NotifierCategoryName = NotifierCategoryBase;
}
else
{
m_NotifierName = notifierName;
m_NotifierCategoryName = string.Format("{0}.{1}", NotifierCategoryBase, notifierName);
}
m_Publisher.LogMessageNotify += Publisher_LogMessageNotify;
}
public void Log(string message, LogMessageCategory category, LogMessageSeverity severity, [CallerMemberName] string callerName = "", [CallerFilePath] string callerFilePath = "", [CallerLineNumber] int callerLineNumber = -1)
{
Trace.TraceInformation(message);
}
public void Log(string message, LogMessageSeverity severity, [CallerMemberName] string callerName = "", [CallerFilePath] string callerFilePath = "", [CallerLineNumber] int callerLineNumber = -1)
{
Log(message, LogMessageCategory.General, severity, callerName, callerFilePath, callerLineNumber);
}
internal void RaiseOnLog(LogMessageSeverity severity, string message)
{
if (LogMessage != null)
LogMessage(this, new LogMessageEventArgs(severity, LogMessageSource.Unknown, message));
}
public LogMessage(String message, LogMessageType type, LogMessageSeverity severity)
{
Message = message;
Type = type;
Severity = severity;
}
internal void Log(LogMessageSeverity severity, string message, Exception exception = null)
=> Logger.Log(this, new MessageLoggedEventArgs("Client", severity, message, exception));
internal LogMessageEventArgs(LogMessageSeverity severity, LogMessageSource source, string msg)
{
Severity = severity;
Source = source;
Message = msg;
}
internal LocalLogMessage(LogMessageSeverity severity, LogWriteMode writeMode, string logSystem, string categoryName,
int skipFrames, string detailsXml, string caption, string description, params object[] args)
: this(severity, writeMode, logSystem, categoryName, skipFrames + 1, null, false, detailsXml, caption, description, args)
{
}
public LogMessage(LogMessageSeverity severity, string message)
: this(severity, message, null)
{
}
public LogMessage(LogMessageSeverity severity, string message, object sender)
{
Severity = severity;
Message = message;
Sender = sender;
}
public void Write(LogMessageSeverity severity, string system, IMessageSourceProvider messageSource, IPrincipal?user, JavaScriptException?jsException,
LogWriteMode mode, string detailsBlock, string?category, string?caption, string?description, object[]?parameters)
{
Log.Write(severity, system, messageSource, user, jsException, mode, detailsBlock, category, caption, description, parameters);
}
public void Write(string message, LogMessageSeverity severity = LogMessageSeverity.Info)
{
}
public DiscordAPIClient(LogMessageSeverity logLevel, string userAgent, int timeout)
{
_rest = new RestClient(logLevel, userAgent, timeout);
}
internal void RaiseOnLog(LogMessageSeverity severity, LogMessageSource source, string message)
{
if (LogMessage != null)
RaiseEvent(nameof(LogMessage), () => LogMessage(this, new LogMessageEventArgs(severity, source, message)));
}
