private async Task ConnectToSlack() { await Client.ConnectAsync(); _logger.Verbose($"Team Name: {Client.MyTeam.name}"); _logger.Verbose($"Bots Name: {Client.MySelf.name}"); await ConnectSocket(); }
/// <inheritdoc /> public void Trace <T1>(string template, T1 parameter1) { if (!IsEnabled(LogLevel.Trace)) { return; } _target.Verbose(template, parameter1); }
// // HELPERS private void LogClaims(ClaimsPrincipal user) { _logger.Verbose("***************************"); _logger.Verbose(string.Format("{0} claims recieved for user {1}", User.Claims.Count <Claim>().ToString(), User.Identity.Name)); foreach (Claim claim in User.Claims) { _logger.Verbose(string.Format(" - {0}: {1}", claim.Type, claim.Value)); } _logger.Verbose("***************************"); }
public void Trace(string template, params object[] values) { if (_inner.IsEnabled(LogEventLevel.Verbose)) { _inner.Verbose(template, values); } }
/// <inheritdoc /> public Task LogMessage(LogMessage message) { switch (message.Severity) { case LogSeverity.Error: case LogSeverity.Critical: _logger.Fatal($"{message.Source}: {message.Message} {message.Exception}"); break; case LogSeverity.Warning: _logger.Warning($"{message.Source}: {message.Message} {message.Exception}"); break; case LogSeverity.Info: _logger.Information($"{message.Source}: {message.Message} {message.Exception}"); break; case LogSeverity.Verbose: _logger.Verbose($"{message.Source}: {message.Message} {message.Exception}"); break; case LogSeverity.Debug: _logger.Debug($"{message.Source}: {message.Message} {message.Exception}"); break; default: throw new ArgumentOutOfRangeException(); } return(Task.CompletedTask); }
private void OnMessageReceived(MessageReader message) { var flag = message.Tag; Logger.Verbose("Server got {0}.", flag); switch (flag) { case MessageFlags.HostGame: { using (var packet = MessageWriter.Get(SendOption.Reliable)) { Message13Redirect.Serialize(packet, false, _nodeProvider.Get()); _connection.Send(packet); } break; } case MessageFlags.JoinGame: { Message01JoinGame.Deserialize(message, out var gameCode, out var unknown); using (var packet = MessageWriter.Get(SendOption.Reliable)) { var endpoint = _nodeLocator.Find(GameCode.IntToGameName(gameCode)); if (endpoint == null) { Message01JoinGame.SerializeError(packet, false, DisconnectReason.GameMissing); } else { Message13Redirect.Serialize(packet, false, endpoint); } _connection.Send(packet); } break; } case MessageFlags.GetGameListV2: { // TODO: Implement. using (var packet = MessageWriter.Get(SendOption.Reliable)) { Message01JoinGame.SerializeError(packet, false, DisconnectReason.Custom, DisconnectMessages.NotImplemented); _connection.Send(packet); } break; } default: { Logger.Warning("Received unsupported message flag on the redirector ({0}).", flag); break; } } }
public override async ValueTask HandleMessageAsync(IMessageReader reader, MessageType messageType) { var flag = reader.Tag; Logger.Verbose("Server got {0}.", flag); switch (flag) { case MessageFlags.HostGame: { using var packet = MessageWriter.Get(MessageType.Reliable); Message13RedirectS2C.Serialize(packet, false, _nodeProvider.Get()); await Connection.SendAsync(packet); break; } case MessageFlags.JoinGame: { Message01JoinGameC2S.Deserialize( reader, out var gameCode, out _); using var packet = MessageWriter.Get(MessageType.Reliable); var endpoint = await _nodeLocator.FindAsync(GameCodeParser.IntToGameName(gameCode)); if (endpoint == null) { Message01JoinGameS2C.SerializeError(packet, false, DisconnectReason.GameMissing); } else { Message13RedirectS2C.Serialize(packet, false, endpoint); } await Connection.SendAsync(packet); break; } case MessageFlags.GetGameListV2: { // TODO: Implement. using var packet = MessageWriter.Get(MessageType.Reliable); Message01JoinGameS2C.SerializeError(packet, false, DisconnectReason.Custom, DisconnectMessages.NotImplemented); await Connection.SendAsync(packet); break; } default: { Logger.Warning("Received unsupported message flag on the redirector ({0}).", flag); break; } } }
public void Log(string category, LogLevel level, string msg, params object[] parameters) { var template = msg; if (!string.IsNullOrEmpty(category)) { template = string.Format("[{0}]: {1}", category, msg); } msg = string.Format(template, parameters); switch (level) { case LogLevel.Trace: _logger.Verbose(msg); break; case LogLevel.Debug: _logger.Debug(msg); break; case LogLevel.Info: _logger.Information(msg); break; case LogLevel.Warning: _logger.Warning(msg); break; case LogLevel.Error: _logger.Error(msg); break; case LogLevel.Critical: _logger.Fatal(msg); break; } }
internal virtual void WakeReminderService(object state) { ReminderServiceLog.Verbose($"{DateTime.Now.ToString(LogDateFormat)} : Waking Reminder Service"); FireRemindersByAssignmentType(); ReminderServiceLog.Verbose($"{DateTime.Now.ToString(LogDateFormat)} : Reminder Service Sleeping"); }
public void Trace(string message) => _logger.Verbose($"[{_loggerName}] {message}");
/// <summary> /// Log a verbose message, by default these aren't output. /// </summary> public void LogVerbose(string message, params object[] args) { serilog.Verbose(message, args); }
public void Verbose <T>(string stringTemplate, T payload = default) { _logger.Verbose <T>(stringTemplate, payload); }
private void OnMessageReceived(MessageReader message, SendOption sendOption) { var flag = (RequestFlag)message.Tag; Logger.Verbose("[{0}] Server got {1}.", Id, flag); switch (flag) { case RequestFlag.HostGame: { // Read game settings. var gameInfoBytes = message.ReadBytesAndSize(); var gameInfo = GameOptionsData.Deserialize(gameInfoBytes); // Create game. var game = _gameManager.Create(this, gameInfo); if (game == null) { Connection.Send(new Message1DisconnectReason(DisconnectReason.ServerFull)); return; } // Code in the packet below will be used in JoinGame. using (var writer = MessageWriter.Get(SendOption.Reliable)) { writer.StartMessage(0); writer.Write(game.Code); writer.EndMessage(); Connection.Send(writer); } break; } case RequestFlag.JoinGame: { var gameCode = message.ReadInt32(); var unknown = message.ReadByte(); var game = _gameManager.Find(gameCode); if (game == null) { Connection.Send(new Message1DisconnectReason(DisconnectReason.GameMissing)); return; } game.HandleJoinGame(Player); break; } case RequestFlag.StartGame: { if (!IsPacketAllowed(message, true)) { return; } Player.Game.HandleStartGame(message); break; } // No idea how this flag is triggered. case RequestFlag.RemoveGame: break; case RequestFlag.RemovePlayer: { if (!IsPacketAllowed(message, true)) { return; } var playerId = message.ReadPackedInt32(); var reason = message.ReadByte(); Player.Game.HandleRemovePlayer(playerId, (DisconnectReason)reason); break; } case RequestFlag.GameData: case RequestFlag.GameDataTo: { if (!IsPacketAllowed(message, false)) { return; } // Broadcast packet to all other players. using (var writer = MessageWriter.Get(sendOption)) { if (flag == RequestFlag.GameDataTo) { var target = message.ReadPackedInt32(); writer.CopyFrom(message); Player.Game.SendTo(writer, target); } else { writer.CopyFrom(message); Player.Game.SendToAllExcept(writer, Player); } } break; } case RequestFlag.EndGame: { if (!IsPacketAllowed(message, true)) { return; } Player.Game.HandleEndGame(message); break; } case RequestFlag.AlterGame: { if (!IsPacketAllowed(message, true)) { return; } if (message.ReadByte() != (byte)AlterGameTags.ChangePrivacy) { return; } var isPublic = message.ReadByte() == 1; Player.Game.HandleAlterGame(message, Player, isPublic); break; } case RequestFlag.KickPlayer: { if (!IsPacketAllowed(message, true)) { return; } var playerId = message.ReadPackedInt32(); var isBan = message.ReadBoolean(); Player.Game.HandleKickPlayer(playerId, isBan); break; } default: Logger.Warning("Server received unknown flag {0}.", flag); break; } if (flag != RequestFlag.GameData && flag != RequestFlag.GameDataTo && flag != RequestFlag.EndGame && message.Position < message.Length) { Logger.Warning("Server did not consume all bytes from {0} ({1} < {2}).", flag, message.Position, message.Length); } }
private void OnMessageReceived(MessageReader message, SendOption sendOption) { var flag = message.Tag; Logger.Verbose("[{0}] Server got {1}.", Id, flag); switch (flag) { case MessageFlags.HostGame: { // Read game settings. var gameInfo = Message00HostGame.Deserialize(message); // Create game. var game = _gameManager.Create(gameInfo); if (game == null) { Player.SendDisconnectReason(DisconnectReason.ServerFull); return; } // Code in the packet below will be used in JoinGame. using (var writer = MessageWriter.Get(SendOption.Reliable)) { Message00HostGame.Serialize(writer, game.Code); Connection.Send(writer); } break; } case MessageFlags.JoinGame: { Message01JoinGame.Deserialize(message, out var gameCode, out var unknown); var game = _gameManager.Find(gameCode); if (game == null) { Player.SendDisconnectReason(DisconnectReason.GameMissing); return; } game.HandleJoinGame(Player); break; } case MessageFlags.StartGame: { if (!IsPacketAllowed(message, true)) { return; } Player.Game.HandleStartGame(message); break; } // No idea how this flag is triggered. case MessageFlags.RemoveGame: break; case MessageFlags.RemovePlayer: { if (!IsPacketAllowed(message, true)) { return; } Message04RemovePlayer.Deserialize(message, out var playerId, out var reason); Player.Game.HandleRemovePlayer(playerId, (DisconnectReason)reason); break; } case MessageFlags.GameData: case MessageFlags.GameDataTo: { if (!IsPacketAllowed(message, false)) { return; } // Broadcast packet to all other players. using (var writer = MessageWriter.Get(sendOption)) { if (flag == MessageFlags.GameDataTo) { var target = message.ReadPackedInt32(); writer.CopyFrom(message); Player.Game.SendTo(writer, target); } else { writer.CopyFrom(message); Player.Game.SendToAllExcept(writer, Player.Client.Id); } } break; } case MessageFlags.EndGame: { if (!IsPacketAllowed(message, true)) { return; } Player.Game.HandleEndGame(message); break; } case MessageFlags.AlterGame: { if (!IsPacketAllowed(message, true)) { return; } Message10AlterGame.Deserialize(message, out var gameTag, out var value); if (gameTag != AlterGameTags.ChangePrivacy) { return; } Player.Game.HandleAlterGame(message, Player, value); break; } case MessageFlags.KickPlayer: { if (!IsPacketAllowed(message, true)) { return; } Message11KickPlayer.Deserialize(message, out var playerId, out var isBan); Player.Game.HandleKickPlayer(playerId, isBan); break; } case MessageFlags.GetGameListV2: { Message16GetGameListV2.Deserialize(message, out var options); Player.OnRequestGameList(options); break; } default: Logger.Warning("Server received unknown flag {0}.", flag); break; } #if DEBUG if (flag != MessageFlags.GameData && flag != MessageFlags.GameDataTo && flag != MessageFlags.EndGame && message.Position < message.Length) { Logger.Warning("Server did not consume all bytes from {0} ({1} < {2}).", flag, message.Position, message.Length); } #endif }
public void Trace(string message) { _logger.Verbose(message); }
public void Verbose(string message, params object[] propertyValues) { _serilog.Verbose(message, propertyValues); LogMessage(LogType.Verbose, message, propertyValues); }
public static IHostBuilder GetHostBuilder(EnvironmentConfiguration environmentConfiguration, IKeyValueConfiguration configuration, ServiceProviderHolder serviceProviderHolder, ILogger logger, string[] commandLineArgs, Action <IServiceCollection>?onRegistration = null) { if (environmentConfiguration == null) { throw new ArgumentNullException(nameof(environmentConfiguration)); } if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } if (serviceProviderHolder == null) { throw new ArgumentNullException(nameof(serviceProviderHolder)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } if (commandLineArgs == null) { throw new ArgumentNullException(nameof(commandLineArgs)); } string contentRoot = environmentConfiguration.ContentBasePath ?? Directory.GetCurrentDirectory(); logger.Debug("Using content root {ContentRoot}", contentRoot); var kestrelServerOptions = new List <KestrelServerOptions>(); IHostBuilder hostBuilder = Microsoft.Extensions.Hosting.Host.CreateDefaultBuilder(commandLineArgs); hostBuilder.ConfigureLogging((_, builder) => builder.AddProvider(new SerilogLoggerProvider(logger))) .ConfigureServices(services => { foreach (var serviceDescriptor in serviceProviderHolder.ServiceCollection) { logger.Verbose("Adding service descriptor {Descriptor}", serviceDescriptor.GetDescription()); services.Add(serviceDescriptor); } services.AddSingleton(environmentConfiguration); services.AddHttpClient(); onRegistration?.Invoke(services); }).ConfigureAppConfiguration((hostingContext, config) => { config.AddKeyValueConfigurationSource(configuration); hostingContext.Configuration = new ConfigurationWrapper((IConfigurationRoot)hostingContext.Configuration, serviceProviderHolder); if (!string.IsNullOrWhiteSpace(environmentConfiguration.ApplicationName)) { hostingContext.HostingEnvironment.ApplicationName = environmentConfiguration.ApplicationName; } }); if (environmentConfiguration.HttpEnabled) { hostBuilder.ConfigureWebHostDefaults(webBuilder => { webBuilder.UseKestrel(options => { if (kestrelServerOptions.Contains(options)) { logger.Debug("Kestrel options has already been configured"); return; } if (environmentConfiguration.UseExplicitPorts) { logger.Debug("Environment configuration is set to use explicit ports"); if (environmentConfiguration.HttpPort.HasValue) { logger.Information("Listening on http port {Port}", environmentConfiguration.HttpPort.Value); options.Listen(IPAddress.Any, environmentConfiguration.HttpPort.Value); } if (environmentConfiguration.HttpsPort.HasValue && environmentConfiguration.PfxFile.HasValue() && environmentConfiguration.PfxPassword.HasValue()) { logger.Information("Listening on https port {Port}", environmentConfiguration.HttpsPort.Value); options.Listen(IPAddress.Any, environmentConfiguration.HttpsPort.Value, listenOptions => { listenOptions.UseHttps(environmentConfiguration.PfxFile, environmentConfiguration.PfxPassword); }); } } kestrelServerOptions.Add(options); }).UseContentRoot(contentRoot) .ConfigureAppConfiguration((_, config) => config.AddEnvironmentVariables()) .UseIISIntegration() .UseDefaultServiceProvider((context, options) => options.ValidateScopes = context.HostingEnvironment.IsDevelopment()).UseStartup <T>(); if (environmentConfiguration.EnvironmentName is { }) { webBuilder.UseEnvironment(environmentConfiguration.EnvironmentName); } }).UseSerilog(logger);
public void LogSystemActivity(string activityType, object data) { serilogLogger.Information(activityType + " - {@data}", data); serilogLogger.Verbose(activityType + " - {@data} - {@StackTrace}", data, Environment.StackTrace); }
/// <summary> /// Log a verbose message. /// </summary> public void LogVerbose(string message, params object[] args) { factoryLogger.Verbose(message, args); mainLogger.LogVerbose(message, args); }