internal static string FormatCompactPayload(IEnumerable <LogEvent> events, long?eventBodyLimitBytes) { var payload = new StringWriter(); foreach (var logEvent in events) { var buffer = new StringWriter(); try { CompactJsonFormatter.FormatEvent(logEvent, buffer, JsonValueFormatter); } catch (Exception ex) { LogNonFormattableEvent(logEvent, ex); continue; } var json = buffer.ToString(); if (CheckEventBodySize(json, eventBodyLimitBytes)) { payload.WriteLine(json); } } return(payload.ToString()); }
private TReturn Query <TReturn>(string apiEndPoint, RestParameterSet parameter, int maxTries) { var para = parameter.CreateParamString(secret); string url = serverbasepath + "/" + apiEndPoint + ".php" + para.Item1; #if DEBUG if (DebugSettings.Get("DebugNetwork")) { SAMLog.Debug($"QueryAsync('{apiEndPoint}', '{url}', {maxTries})"); } #endif for (;;) { try { HttpResponseMessage response; if (para.Item2 != null) { response = http.PostAsync(url, para.Item2).Result; } else { response = http.GetAsync(url).Result; } response.EnsureSuccessStatusCode(); var content = response.Content.ReadAsStringAsync().Result; #if DEBUG if (DebugSettings.Get("DebugNetwork")) { var json = CompactJsonFormatter.CompressJson(content, 1); var jlines = json.Replace("\r\n", "\n").Split('\n'); if (jlines.Length > 7) { json = string.Join("\n", jlines.Take(3).Concat(new[] { "..." }).Concat(jlines.Reverse().Take(3).Reverse())); } SAMLog.Debug($"Query '{apiEndPoint}' returned \r\n" + json); } #endif return(JsonConvert.DeserializeObject <TReturn>(content)); } catch (Exception e) { if (maxTries > 0) { maxTries--; SAMLog.Info("QueryAsync", $"Retry query '{url}'. {maxTries}remaining", e.Message); MonoSAMGame.CurrentInst.Bridge.Sleep(RETRY_SLEEP_TIME); continue; } else { throw new RestConnectionException(e); // return to sender } } } }
private static Logger OverrideEverything(string url) { ITextFormatter textFormatter = new CompactJsonFormatter(); return(new LoggerConfiguration() .WriteTo.Console() .WriteTo.Async(configuration => configuration.SumoLogic( url, sourceName: "CustomSourceName", sourceCategory: "CustomSourceCategory", restrictedToMinimumLevel: LogEventLevel.Debug, batchSizeLimit: 20, period: TimeSpan.FromSeconds(1), textFormatter: new CompactJsonFormatter())) // use in console apps .WriteTo.SumoLogic( url, sourceName: "CustomSourceName", sourceCategory: "CustomSourceCategory", restrictedToMinimumLevel: LogEventLevel.Debug, batchSizeLimit: 20, period: TimeSpan.FromSeconds(1), textFormatter: new CompactJsonFormatter()) // use in ASP.NET .CreateLogger()); }
private void Configure(IApplicationBuilder app) { var formatter = new CompactJsonFormatter(); app.Run( ctx => { if (ctx.Request.Method == "GET") { ctx.Response.StatusCode = 200; ctx.Response.ContentType = "application/vnd.serilog.clef"; using (var writer = new StreamWriter(ctx.Response.Body, System.Text.Encoding.UTF8)) { while (this.logEvents.TryPop(out var logEvent)) { formatter.Format(logEvent, writer); } } ctx.Response.Body.Flush(); } else if (ctx.Request.Method == "DELETE") { this.logEvents.Clear(); } else { ctx.Response.StatusCode = (int)HttpStatusCode.NotImplemented; } return(Task.CompletedTask); }); }
public static LoggerConfiguration AppendAwsCloudwatchLogger(this LoggerConfiguration logger, string logGroupName, string environmentName, LogEventLevel minimumLogEvent) { logGroupName = $"{logGroupName}/{environmentName}".ToLower(); var formatter = new CompactJsonFormatter(); var options = new CloudWatchSinkOptions { LogGroupName = logGroupName, TextFormatter = formatter, MinimumLogEventLevel = minimumLogEvent, BatchSizeLimit = 100, QueueSizeLimit = 10000, Period = TimeSpan.FromSeconds(10), CreateLogGroup = true, LogStreamNameProvider = new DefaultLogStreamProvider(), RetryAttempts = 5, LogGroupRetentionPolicy = LogGroupRetentionPolicy.OneDay }; var client = new AmazonCloudWatchLogsClient(RegionEndpoint.SAEast1); return(logger //.Filter.ByExcluding(c => c.Properties.Any(p => p.Value.ToString().Contains("swagger"))) .WriteTo.AmazonCloudWatch(options, client)); }
public void ConfigureLogging(LoggerConfiguration loggerConfiguration, HostingEnvironment hostingEnvironment) { var fileFormatter = new CompactJsonFormatter(); //Serilog.Core.Logger auditLogger = new LoggerConfiguration() // .Filter.ByIncludingOnly(Matching.FromSource<Audit>()) // .AuditTo.File(fileFormatter, "audit-logger.json") // .CreateLogger(); Serilog.Core.Logger applicationLogger = new LoggerConfiguration() .Filter().Overrides(globalSwitches) .WriteTo.File(fileFormatter, "application-logger.json", shared: true) .CreateLogger(); loggerConfiguration .MinimumLevel.Verbose() .Enrich.FromLogContext() //.AuditTo.Logger(auditLogger) .WriteTo.Logger(applicationLogger) .WriteTo.Console( outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3} {SourceContext}] {Message:lj}{NewLine}{Properties:j}{NewLine}{Exception}", theme: GetTheme(hostingEnvironment) ) .WriteTo.Seq(serverUrl: "http://localhost:5341", compact: true); }
internal static string FormatCompactPayload(LogEvent logEvent) { var payload = new StringWriter(); CompactJsonFormatter.FormatEvent(logEvent, payload, JsonValueFormatter); payload.WriteLine(); return(payload.ToString()); }
private static Logger CustomTextFormatter(string url) { ITextFormatter textFormatter = new CompactJsonFormatter(); return(new LoggerConfiguration() .WriteTo.Console() .WriteTo.Async(configuration => configuration.SumoLogic(url, "CustomTextFormatter", textFormatter: textFormatter)) // use in console apps .WriteTo.SumoLogic(url, "CustomTextFormatter", textFormatter: textFormatter) // use in ASP.NET .CreateLogger()); }
public static LoggerConfiguration SuperRollingFileAlternate( this LoggerSinkConfiguration configuration, string logDirectory, string logFilePrefix = "", SuperRollingFileAlternateFormats format = SuperRollingFileAlternateFormats.Text, ITextFormatter formatter = null, LogEventLevel minimumLevel = LevelAlias.Minimum, long fileSizeLimitBytes = DefaultFileSizeLimitBytes, int?retainedFileCountLimit = DefaultRetainedFileCountLimit, Encoding encoding = null, bool renderMessage = false, bool async = false, string outputTemplate = DefaultOutputTemplate, IFormatProvider formatProvider = null) { if (formatter == null) { switch (format) { case SuperRollingFileAlternateFormats.Json: formatter = new JsonFormatter(renderMessage: renderMessage); break; case SuperRollingFileAlternateFormats.CompactJson: formatter = new CompactJsonFormatter(); break; case SuperRollingFileAlternateFormats.Text: default: formatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider); break; } } var sink = new AlternateRollingFileSink(logDirectory, formatter, fileSizeLimitBytes, retainedFileCountLimit, encoding, logFilePrefix); if (async) { return(configuration.Async(c => c.Sink(sink, minimumLevel))); } else { return(configuration.Sink(sink, minimumLevel)); } }
private ILogger CreateLogger(string gameDirectory, LoggingConfiguration loggingConfiguration, ForwardingTextWriter logTextWriter) { var config = new LoggerConfiguration(); config.MinimumLevel.Verbose(); ITextFormatter fileFormatter = null; switch (loggingConfiguration.LogFormat) { case LoggingConfiguration.Format.Text: { fileFormatter = new MessageTemplateTextFormatter("{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}", null); break; } case LoggingConfiguration.Format.CompactJSON: { fileFormatter = new CompactJsonFormatter(); break; } } //Invalid config setting for RetainedFileCountLimit will throw config .WriteTo.File(fileFormatter, $"{gameDirectory}/logs/engine.log", rollingInterval: RollingInterval.Day, retainedFileCountLimit: loggingConfiguration.RetainedFileCountLimit); //Use basic formatting for console output var logFormatter = new MessageTemplateTextFormatter("{Message:lj}{NewLine}{Exception}", null); if (logTextWriter != null) { config.WriteTo.TextWriter(logFormatter, logTextWriter); } return(config.CreateLogger()); }
public static LoggerConfiguration AppendAwsCloudwatchLogger(this LoggerConfiguration logger, string logGroupName, LogEventLevel minimumLogEvent, string accessKey, string securityKey) { // customer formatter var formatter = new CompactJsonFormatter(); // options for the sink defaults in https://github.com/Cimpress-MCP/serilog-sinks-awscloudwatch/blob/master/src/Serilog.Sinks.AwsCloudWatch/CloudWatchSinkOptions.cs var options = new CloudWatchSinkOptions { LogGroupName = logGroupName, TextFormatter = formatter, MinimumLogEventLevel = minimumLogEvent, LogStreamNameProvider = new DefaultLogStreamProvider(), RetryAttempts = 5 }; var credentials = new BasicAWSCredentials(accessKey, securityKey); // setup AWS CloudWatch client var client = new AmazonCloudWatchLogsClient(credentials, RegionEndpoint.EUWest1); return(logger .WriteTo.AmazonCloudWatch(options, client)); }
/// <remarks> /// Used in config - If renamed or moved to other assembly the config file also has be updated. /// </remarks> public static LoggerConfiguration UmbracoFile(this LoggerSinkConfiguration configuration, string path, ITextFormatter formatter = null, LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose, LoggingLevelSwitch levelSwitch = null, long?fileSizeLimitBytes = 1073741824, TimeSpan?flushToDiskInterval = null, RollingInterval rollingInterval = RollingInterval.Day, bool rollOnFileSizeLimit = false, int?retainedFileCountLimit = 31, Encoding encoding = null ) { if (formatter is null) { formatter = new CompactJsonFormatter(); } return(configuration.Async( asyncConfiguration => asyncConfiguration.Map(AppDomainId, (_, mapConfiguration) => mapConfiguration.File( formatter, path, restrictedToMinimumLevel, fileSizeLimitBytes, levelSwitch, buffered: true, shared: false, flushToDiskInterval, rollingInterval, rollOnFileSizeLimit, retainedFileCountLimit, encoding, null), sinkMapCountLimit: 0) )); }
private static void ConfigureLogger(HostBuilderContext hostBuilderContext, LoggerConfiguration loggerConfiguration) { if (Debugger.IsAttached) { // allow serilog warnings to show when running in debug // see https://github.com/serilog/serilog/wiki/Debugging-and-Diagnostics // if you're having issues with serilog in some environments (sandbox/uat/prod) consider enabling this Serilog.Debugging.SelfLog.Enable(Console.Error); } // setup your serilog logger configuration // the configuration below is just an example, you should configure it as it fits your use case var jsonValueFormatter = new JsonValueFormatter(typeTagName: null); //passing null removes $type from being added to all serialized objects var jsonFormatter = new CompactJsonFormatter(jsonValueFormatter); var exceptionDetailsDeconstructorers = new DestructuringOptionsBuilder().WithDefaultDestructurers(); loggerConfiguration.ReadFrom.Configuration(hostBuilderContext.Configuration) .Destructure.UsingAttributes() .Enrich.FromLogContext() .Enrich.WithExceptionDetails(exceptionDetailsDeconstructorers) .Enrich.WithMachineName() .Enrich.WithEnvironmentName() .WriteTo.Console(jsonFormatter); }
private static LoggerConfiguration configFromWebApiConfig(LoggerConfiguration loggerConfiguration, WebApiConfig apiConfig) { apiConfig = apiConfig ?? new WebApiConfig(); loggerConfiguration.MinimumLevel.ControlledBy(apiConfig.InnerSerilogLevels.AppLogLevel) .MinimumLevel.Override("Microsoft", apiConfig.InnerSerilogLevels.SystemLogLevel) .MinimumLevel.Override("System", apiConfig.InnerSerilogLevels.SystemLogLevel) .MinimumLevel.Override("Microsoft.AspNetCore", apiConfig.InnerSerilogLevels.AppLogLevel) .MinimumLevel.Override("Microsoft.Hosting", apiConfig.InnerSerilogLevels.AppLogLevel) .MinimumLevel.Override("Microsoft.EntityFrameworkCore.Database.Command", apiConfig.InnerSerilogLevels.EFCoreCommandLevel) .MinimumLevel.Override("System.Net.Http.HttpClient", apiConfig.InnerSerilogLevels.AppLogLevel) .MinimumLevel.Override("ServerRequest.Logger", apiConfig.InnerSerilogLevels.ServerRequestLevel) .MinimumLevel.Override("ClientRequest.Logger", apiConfig.InnerSerilogLevels.ClientRequestLevel) .Destructure.ToMaximumStringLength(apiConfig.MaxLogLength); loggerConfiguration = loggerConfiguration.Enrich.FromLogContext(); if (apiConfig.ConsoleJsonLog) { loggerConfiguration = loggerConfiguration.WriteTo.Console(new CompactJsonFormatter(apiConfig)); } else if (apiConfig.ConsoleLog) { loggerConfiguration = loggerConfiguration.WriteTo.Console(); } else { loggerConfiguration = loggerConfiguration.WriteTo.Console(Serilog.Events.LogEventLevel.Warning); } if (apiConfig.FileLog || apiConfig.FileJsonLog) { string path = apiConfig.GetLogPath(); string pathTemplate = apiConfig.LogPathTemplate; if (string.IsNullOrEmpty(pathTemplate)) { pathTemplate = LogPathTemplates.DayFolderAndLoggerNameFile; } Serilog.Formatting.Display.MessageTemplateTextFormatter pathFormatter = new Serilog.Formatting.Display.MessageTemplateTextFormatter(pathTemplate); ArchiveHooks archiveHooks = new ArchiveHooks(CompressionLevel.Fastest); string template = apiConfig.LogTemplate; if (string.IsNullOrEmpty(template)) { template = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{NewLine}{Exception}"; } bool keySelector(Serilog.Events.LogEvent logEvent, out LogPathAndTimeKey key) { StringWriter sw = new StringWriter(); StringBuilder sb = new StringBuilder(); pathFormatter.Format(logEvent, sw); sw.Flush(); string dp = sw.GetStringBuilder().ToString(); string p = Path.Combine(path, dp); key = new LogPathAndTimeKey() { Path = p, Time = logEvent.Timestamp.Date }; return(true); }; if (apiConfig.FileJsonLog) { var formatter = new CompactJsonFormatter(apiConfig); loggerConfiguration = loggerConfiguration .WriteTo.MapCondition <LogPathAndTimeKey>(keySelector, (path, lc) => { lc.Async(lc => lc.File( formatter, path.Path, rollingInterval: RollingInterval.Infinite, rollOnFileSizeLimit: true, fileSizeLimitBytes: apiConfig.MaxLogFileSize, retainedFileCountLimit: apiConfig.RetainedFileCount, hooks: archiveHooks)); }, key => { // 自动Dispose前一天的日志 DateTimeOffset now = DateTimeOffset.Now.Date; if (now > key.Time.Date) { return(true); } return(false); }); } else { loggerConfiguration = loggerConfiguration .WriteTo.MapCondition <LogPathAndTimeKey>(keySelector, (path, lc) => { lc.Async(lc => lc.File( path.Path, rollingInterval: RollingInterval.Infinite, rollOnFileSizeLimit: true, fileSizeLimitBytes: apiConfig.MaxLogFileSize, retainedFileCountLimit: apiConfig.RetainedFileCount, hooks: archiveHooks, outputTemplate: template)); }, key => { // 自动Dispose前一天的日志 DateTimeOffset now = DateTimeOffset.Now.Date; if (now > key.Time.Date) { return(true); } return(false); }); } } return(loggerConfiguration); }
public static SyncResult Sync(ISimpleJsonRest web, StandardNoteConnection conn, APIResultAuthorize authToken, StandardNoteConfig cfg, StandardNoteData dat, List <StandardFileNote> allNotes, List <StandardFileNote> notesUpload, List <StandardFileNote> notesDelete, List <StandardFileTag> tagsDelete) { APIBodySync d = new APIBodySync(); d.cursor_token = null; d.sync_token = string.IsNullOrWhiteSpace(dat.SyncToken) ? null : dat.SyncToken; d.limit = 150; d.items = new List <APIBodyItem>(); var items_raw = new List <APIRawBodyItem>(); var allTags = dat.Tags.ToList(); // Upload new notes foreach (var mvNote in notesUpload) { PrepareNoteForUpload(web, d, ref items_raw, mvNote, allTags, authToken, cfg, false); } // Delete deleted notes foreach (var rmNote in notesDelete) { PrepareNoteForUpload(web, d, ref items_raw, rmNote, allTags, authToken, cfg, true); } // Update references on tags (from changed notes) foreach (var upTag in GetTagsInNeedOfUpdate(dat.Tags, notesUpload, notesDelete)) { PrepareTagForUpload(web, d, ref items_raw, upTag, authToken, false); } // Remove unused tags if (cfg.RemEmptyTags) { foreach (var rmTag in tagsDelete) { PrepareTagForUpload(web, d, ref items_raw, rmTag, authToken, true); } } Logger.Debug( StandardNotePlugin.Name, $"Perform sync request ({items_raw.Count} items send)", "Sent Items (unencrypted):\n\n" + string.Join("\n", items_raw.Select(i => $"{{\n content_type = {i.content_type}\n uuid = {i.uuid}\n created_at = {i.created_at}\n deleted = {i.deleted}\n content =\n{CompactJsonFormatter.FormatJSON(i.content, 2, 1)}\n}}"))); var result = GetCursorResult(web, dat, d); var syncresult = new SyncResult(); syncresult.retrieved_tags = result .retrieved_items .Where(p => p.content_type.ToLower() == "tag") .Where(p => !p.deleted) .Select(n => CreateTag(web, n, authToken)) .ToList(); syncresult.deleted_tags = result .retrieved_items .Where(p => p.content_type.ToLower() == "tag") .Where(p => p.deleted) .Select(n => CreateTag(web, n, authToken)) .ToList(); syncresult.saved_tags = result .saved_items .Where(p => p.content_type.ToLower() == "tag") .Select(n => CreateTag(web, n, authToken)) .ToList(); syncresult.unsaved_tags = result .unsaved .Where(p => p.item.content_type.ToLower() == "tag") .Select(n => CreateTag(web, n.item, authToken)) .ToList(); dat.UpdateTags(syncresult.retrieved_tags, syncresult.saved_tags, syncresult.unsaved_tags, syncresult.deleted_tags); syncresult.retrieved_notes = result .retrieved_items .Where(p => p.content_type.ToLower() == "note") .Where(p => !p.deleted) .Select(n => CreateNote(web, conn, n, authToken, cfg, dat)) .ToList(); syncresult.deleted_notes = result .retrieved_items .Where(p => p.content_type.ToLower() == "note") .Where(p => p.deleted) .Select(n => CreateNote(web, conn, n, authToken, cfg, dat)) .ToList(); syncresult.saved_notes = result .saved_items .Where(p => p.content_type.ToLower() == "note") .Select(n => CreateNote(web, conn, n, authToken, cfg, dat)) .ToList(); syncresult.conflict_notes = result .unsaved .Where(p => p.item.content_type.ToLower() == "note") .Where(p => p.error.tag == "sync_conflict") .Select(n => CreateNote(web, conn, n.item, authToken, cfg, dat)) .ToList(); syncresult.error_notes = result .unsaved .Where(p => p.item.content_type.ToLower() == "note") .Where(p => p.error.tag != "sync_conflict") .Select(n => CreateNote(web, conn, n.item, authToken, cfg, dat)) .ToList(); syncresult.retrieved_notes.AddRange(GetMissingNoteUpdates(syncresult.retrieved_tags.Concat(syncresult.saved_tags), dat.Tags, allNotes, syncresult.retrieved_notes)); return(syncresult); }