public async Task <MimeMessage> RunAsync(MimeMessage message, ISessionContext context, IMessageTransaction transaction, CancellationToken cancellationToken) { _logger?.Log(LogLevel.Information, "Injecting headers into message"); try { //Add headers to the top of the message var bodyTextParts = message.BodyParts.OfType <TextPart>().ToList(); var htmlBody = bodyTextParts.LastOrDefault(btp => btp.IsHtml); var textBody = bodyTextParts.LastOrDefault(btp => !btp.IsHtml); if (htmlBody != null) { var bodyTagLocation = htmlBody.Text.IndexOf("<body>", StringComparison.OrdinalIgnoreCase); var insertLocation = bodyTagLocation == -1 ? 0 : bodyTagLocation + 6; htmlBody.Text = htmlBody.Text.Insert(insertLocation, $"\n{HeaderFormatter.GetHtmlHeaders(message)}"); } if (textBody != null) { textBody.Text = $"{HeaderFormatter.GetPlainTextHeaders(message)}\n{textBody.Text}"; } } catch (Exception exception) { _logger?.Log(LogLevel.Error, exception, "Error injecting headers into message"); //Don't throw, continue routing message } return(await Task.FromResult(message).ConfigureAwait(false)); }
public async Task <MimeMessage> RunAsync(MimeMessage message, ISessionContext context, IMessageTransaction transaction, CancellationToken cancellationToken) { _logger?.Log(LogLevel.Information, "Sending message"); try { using (var smtpClient = await _create(cancellationToken)) { await _connect(smtpClient, cancellationToken); if (_authenticate != null) { await _authenticate(smtpClient, cancellationToken); } await smtpClient.SendAsync(message, cancellationToken).ConfigureAwait(false); } } catch (Exception exception) { _logger?.Log(LogLevel.Error, exception, "Unable to send message"); throw; } return(message); }
public async Task <MimeMessage> RunAsync(MimeMessage message, ISessionContext context, IMessageTransaction transaction, CancellationToken cancellationToken) { _logger?.Log(LogLevel.Information, "Rerouting message"); try { var toKeep = message.To.Mailboxes.Where(m => _keepAddressPredicates != null && _keepAddressPredicates.Any(p => p(m.ToString()))).ToList(); var ccKeep = message.Cc.Mailboxes.Where(m => _keepAddressPredicates != null && _keepAddressPredicates.Any(p => p(m.ToString()))).ToList(); var bccKeep = message.Bcc.Mailboxes.Where(m => _keepAddressPredicates != null && _keepAddressPredicates.Any(p => p(m.ToString()))).ToList(); message.To.Clear(); message.Cc.Clear(); message.Bcc.Clear(); message.To.AddRange(toKeep); message.Cc.AddRange(ccKeep); message.Bcc.AddRange(bccKeep); message.To.AddRange(_rerouteToInternetAddresses.Select(a => new MailboxAddress(a))); } catch (Exception exception) { _logger?.Log(LogLevel.Error, exception, "Unable to reroute message"); throw; //If error, abort so external customers don't get messages } return(await Task.FromResult(message).ConfigureAwait(false)); }
public async Task <MimeMessage> RunAsync(MimeMessage message, ISessionContext context, IMessageTransaction transaction, CancellationToken cancellationToken) { _logger?.Log(LogLevel.Information, $"Adding BCC to {string.Join(", ", _bccEmails)}"); try { message.Bcc.AddRange(_bccEmails.Select(bcc => new MailboxAddress(bcc))); } catch (Exception exception) { _logger?.Log(LogLevel.Error, exception, $"Error adding BCC to {string.Join(", ", _bccEmails)}"); //Don't throw, continue routing message } return(await Task.FromResult(message).ConfigureAwait(false)); }
public async Task <MimeMessage> RunAsync(MimeMessage message, ISessionContext context, IMessageTransaction transaction, CancellationToken cancellationToken) { _logger?.Log(LogLevel.Information, "Adding headers as an attachment"); try { var stream = new MemoryStream(); var streamWriter = new StreamWriter(stream); streamWriter.Write(HeaderFormatter.GetPlainTextHeaders(message)); streamWriter.Flush(); stream.Position = 0; var attachment = new MimePart("text", "plain") { Content = new MimeContent(stream), ContentDisposition = new ContentDisposition(ContentDisposition.Attachment), ContentTransferEncoding = ContentEncoding.Base64, FileName = "OriginalHeaders.txt" }; //Add the attachment to the existing parent-level multipart if it exists. //Otherwise create a parent multipart and put the message body and attachment in it. if (message.Body is Multipart multipart) { multipart.Add(attachment); } else { message.Body = new Multipart("mixed") { message.Body, attachment }; } } catch (Exception exception) { _logger?.Log(LogLevel.Error, exception, "Error adding headers as an attachment"); //Don't throw, continue routing message } return(await Task.FromResult(message).ConfigureAwait(false)); }
/// <summary> /// This method is called when the <see cref="T:Microsoft.Extensions.Hosting.IHostedService" /> starts. The implementation should return a task that represents /// the lifetime of the long running operation(s) being performed. /// </summary> /// <param name="stoppingToken">Triggered when <see cref="M:Microsoft.Extensions.Hosting.IHostedService.StopAsync(System.Threading.CancellationToken)" /> is called.</param> /// <returns> /// A <see cref="T:System.Threading.Tasks.Task" /> that represents the long running operations. /// </returns> protected override async Task ExecuteAsync(CancellationToken stoppingToken) { // create subscriptions to the channels await Task.Run(() => { _subscriptions.ForEach(s => { s.Subscribe(_natsUrl); s.Start().GetAwaiter().GetResult(); }); _logger?.Log(LogLevel.Information, "All subscriptions started."); }); }
/// <summary> /// Initializes a new base instance of the <see cref="NatsSubscriptionBackgroundService" /> class. /// </summary> /// <param name="natsUrl">The nats URL.</param> /// <param name="group">The queue group.</param> /// <param name="logger">The logger.</param> /// <param name="registerMethods">The registrarion action.</param> protected JsonRpcSubscriptionBackgroundService(string natsUrl, string group, ILoggerProvider logger, Action <JsonRpcServiceProxyWrapper> registerMethods) { _logger = logger.CreateLogger(MethodBase.GetCurrentMethod().DeclaringType.FullName); _natsUrl = natsUrl; _wrapper = new JsonRpcServiceProxyWrapper(); registerMethods(_wrapper); foreach (string channel in _wrapper.Methods) { _logger?.Log(LogLevel.Information, $"Create subscription {channel}"); _subscriptions.Add(new JsonRpcSubscription(channel, group, _wrapper, _logger)); } }
public void Log(NuGet.Common.LogLevel level, string data) { logger.Log(ConvertLevel(level), $"NuGet [{fileName}]: {data}"); }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception?exception, Func <TState, Exception?, string>?formatter) { Logged?.Invoke(logLevel, eventId, state, exception, formatter != null ? (o, e) => formatter((TState)o, e) : null); _baseLogger.Log(logLevel, eventId, state, exception, formatter); }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { adaptee.Log(logLevel, eventId, state, exception, formatter); }
public void Log <TState>(Microsoft.Extensions.Logging.LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { _logger.Log(logLevel, eventId, new MyLogEvent <TState>(state, formatter).AddProp("ActivityId", 42), exception, MyLogEvent <TState> .Formatter); }
void Microsoft.Extensions.Logging.ILogger.Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) => logger.Log <TState>(logLevel, eventId, state, exception, formatter);
public void Log(string details) => microsoftLogger.Log(LogLevel.Information, details);
public bool WriteCore(TraceEventType eventType, int eventId, object state, Exception exception, Func <object, Exception, string> formatter) { _logger.Log(MapToLogLevel(eventType), eventId, state, exception, formatter); return(true); }
public void Log(DnsClient.Internal.LogLevel logLevel, int eventId, Exception exception, string message, params object[] args) { _logger.Log((Microsoft.Extensions.Logging.LogLevel)logLevel, eventId, exception, message, args); }
/// <inheritdoc/> public void Write(LogLevel logLevel, string message, params object[] args) => _logger.Log(TranslateLogLevel(logLevel), message, args);
public void Log(LogMessageReceivedEventArgs logEvent) { _baseLogger.Log(TranslateLogLevel(logEvent.MessageType), logEvent.Message); }
public void Log(NHibernateLogLevel logLevel, NHibernateLogValues state, Exception exception) { _msLogger.Log(MapLevels[logLevel], 0, new FormattedLogValues(state.Format, state.Args), exception, MessageFormatter); }
public void WriteLine(string line) { _extLogger.Log(LogLevel.Trace, $"[HEXDUMP] {line}"); }
protected override void WriteInternal(Acb.Core.Logging.LogLevel level, object message, Exception exception) { var msg = message.GetType().IsSimpleType() ? message.ToString() : JsonConvert.SerializeObject(message); _logger.Log(Convert(level), new EventId(0), exception, msg); }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) => _logger.Log <TState>(logLevel, eventId, state, exception, formatter);
public void Write(EventType eventType, Func <string> logMessage) { _logger.Log(MapEventTypeToLogLevel(eventType), 0, logMessage, null, (state, exception) => state()); }
public async Task <MimeMessage> RunAsync(MimeMessage message, ISessionContext context, IMessageTransaction transaction, CancellationToken cancellationToken) { _logger?.Log(LogLevel.Information, "Rerouting message"); try { var routes = _rerouteRules.Where(r => r.Rule(message, context, transaction)).ToArray(); _logger?.Log(LogLevel.Information, $"Found {routes.Length} matching routes: {string.Join(", ", routes.Select(r => r.Name))}"); ICollection <string> toEmails = routes.SelectMany(r => r.ToEmails) .Distinct(new EmailEqualityComparer()) .ToArray(); _logger?.Log(LogLevel.Information, $"Rerouting email to {string.Join(", ", toEmails)}"); if (!toEmails.Any()) { if (_defaultReroute == null) { throw new Exception("No route found and no default route specified"); } _logger?.Log(LogLevel.Information, "No route found. Using default route."); toEmails = _defaultReroute; } var toKeep = message.To.Mailboxes.Where(m => _keepAddressPredicates != null && _keepAddressPredicates.Any(p => p(m.ToString()))).ToList(); if (toKeep.Any()) { _logger?.Log(LogLevel.Information, $"Keeping To addresses {string.Join(", ", toKeep)}"); } var ccKeep = message.Cc.Mailboxes.Where(m => _keepAddressPredicates != null && _keepAddressPredicates.Any(p => p(m.ToString()))).ToList(); if (ccKeep.Any()) { _logger?.Log(LogLevel.Information, $"Keeping CC addresses {string.Join(", ", ccKeep)}"); } var bccKeep = message.Bcc.Mailboxes.Where(m => _keepAddressPredicates != null && _keepAddressPredicates.Any(p => p(m.ToString()))).ToList(); if (ccKeep.Any()) { _logger?.Log(LogLevel.Information, $"Keeping BCC addresses {string.Join(", ", bccKeep)}"); } message.To.Clear(); message.Cc.Clear(); message.Bcc.Clear(); message.To.AddRange(toKeep); message.Cc.AddRange(ccKeep); message.Bcc.AddRange(bccKeep); message.To.AddRange(toEmails.Select(r => new MailboxAddress(r))); } catch (Exception exception) { _logger?.Log(LogLevel.Error, exception, "Unable to reroute message"); throw; //If error, abort so external customers don't get messages } return(await Task.FromResult(message).ConfigureAwait(false)); }
static async Task Main(string[] args) { var serilogger = new LoggerConfiguration() .WriteTo.File("log.txt", rollingInterval: RollingInterval.Day) .CreateLogger(); var loggerFactory = LoggerFactory.Create(builder => { builder // .AddFilter("Microsoft", LogLevel.Warning) // .AddFilter("System", LogLevel.Warning) // .AddFilter("LoggingConsoleApp.Program", LogLevel.Debug) .AddSerilog(serilogger) .AddConsole(); }); _logger = loggerFactory.CreateLogger <Program>(); // Register extensions to Json.NET Serialization JsonConvert.DefaultSettings = () => new JsonSerializerSettings { Converters = new List <JsonConverter> { new MathJsonConverter(), Converter.DateTimeConverter, Converter.BinaryConverter, Converter.GroupingConverter, Converter.PocoExprConverter } }; Converter.Serializer.Converters.Add(new MathJsonConverter()); // Register extensions to MessagePack Serialization var resolver = CompositeResolver.Create( MathResolver.Instance, NativeGuidResolver.Instance, StandardResolver.Instance ); var options = MessagePackSerializerOptions.Standard.WithResolver(resolver); MessagePackSerializer.DefaultOptions = options; var connection = R.Connection().Hostname("asgard.gamecult.games") .Port(RethinkDBConstants.DefaultPort).Timeout(60).Connect(); var cache = new DatabaseCache(); // When entries are changed locally, push the changes to RethinkDB cache.OnDataUpdateLocal += async entry => { var table = entry.GetType().GetCustomAttribute <RethinkTableAttribute>()?.TableName ?? "Other"; var result = await R.Db("Aetheria").Table(table).Update(entry).RunAsync(connection); _logger.Log(LogLevel.Information, $"Uploaded entry to RethinkDB: {entry.ID} result: {result}"); }; cache.OnDataInsertLocal += async entry => { var table = entry.GetType().GetCustomAttribute <RethinkTableAttribute>()?.TableName ?? "Other"; var inserted = false; for (int i = 0; i < 5 && !inserted; i++) { try { var result = await R.Db("Aetheria").Table(table).Insert(entry).RunAsync(connection); _logger.Log(LogLevel.Information, $"Inserted entry to RethinkDB: {entry.ID} result: {result}"); inserted = true; } catch (Exception e) { _logger.LogError(e, e.Message); } } if (!inserted) { _logger.LogError("Failed to insert after 5 attempts!"); } }; cache.OnDataDeleteLocal += async entry => { var table = entry.GetType().GetCustomAttribute <RethinkTableAttribute>()?.TableName ?? "Other"; var result = await R.Db("Aetheria").Table(table).Get(entry.ID).Delete().RunAsync(connection); _logger.Log(LogLevel.Information, $"Deleted entry from RethinkDB: {entry.ID} result: {result}"); }; // Get data from RethinkDB await GetTable("Items", connection, cache); await GetTable("Galaxy", connection, cache); await GetTable("Users", connection, cache); // Subscribe to changes from RethinkDB SubscribeTable("Items", connection, cache); SubscribeTable("Galaxy", connection, cache); SubscribeTable("Users", connection, cache); var server = new MasterServer(cache) { Logger = _logger }; server.Start(); var context = new GameContext(cache, s => _logger.Log(LogLevel.Information, s)); context.MapLayers = cache.GetAll <GalaxyMapLayerData>().ToDictionary(m => m.Name); server.AddMessageListener <GalaxyRequestMessage>(galaxyRequest => galaxyRequest.Peer.Send( new GalaxyResponseMessage { Zones = cache.GetAll <ZoneData>().Select(zd => new GalaxyResponseZone { Name = zd.Name, Position = zd.Position, ZoneID = zd.ID, Links = zd.Wormholes?.ToArray() ?? Array.Empty <Guid>() }).ToArray(), GlobalData = context.GlobalData, StarDensity = context.MapLayers["StarDensity"] })); server.AddMessageListener <BlueprintsRequestMessage>(blueprintRequest => blueprintRequest.Peer.Send( new BlueprintsResponseMessage { Blueprints = cache.GetAll <BlueprintData>().ToArray() })); server.AddMessageListener <ZoneRequestMessage>(zoneRequest => { var zone = cache.Get <ZoneData>(zoneRequest.ZoneID); // Zone has not been populated, generate the contents now! if (!zone.Visited) { zone.Visited = true; OrbitData[] orbits; PlanetData[] planets; ZoneGenerator.GenerateZone( global: context.GlobalData, zone: zone, mapLayers: context.MapLayers.Values, resources: cache.GetAll <SimpleCommodityData>().Where(i => i.ResourceDensity.Any()), orbitData: out orbits, planetsData: out planets); cache.AddAll(orbits); cache.AddAll(planets); cache.Add(zone); } zoneRequest.Peer.Send( new ZoneResponseMessage { Zone = zone, Contents = zone.Orbits.Select(id => cache.Get(id)) .Concat(zone.Planets.Select(id => cache.Get(id))) .Concat(zone.Stations.Select(id => cache.Get(id))).ToArray() }); }); Observable.Timer(DateTimeOffset.Now, TimeSpan.FromSeconds(60)).SubscribeOn(NewThreadScheduler.Default).Subscribe(_ => { _logger.Log(LogLevel.Information, R.Now().Run <DateTime>(connection).ToString() as string); }); while (true) { Thread.Sleep(100); } }