Update logging with new abstraction/configuration

Author: Migaroez

16/umbraco-cms/fundamentals/backoffice/logviewer.md

@@ -30,13 +30,13 @@ Here are some example queries to help you get started. For more details on the s
 
 If you frequently use a custom query, you can save it for quick access. Type your query in the search box and click the heart icon to save it with a friendly name. Saved queries are stored in the `umbracoLogViewerQuery` table in the database.
 
-## Implementing Your Own Log Viewer
+## Implementing Your Own Log Viewer Source
 
-Umbraco allows you to implement a customn `ILogViewer` to fetch logs from alternative sources, such as **Azure Table Storage**.
+Umbraco allows you to implement a customn `ILogViewerRepository` to fetch logs from alternative sources, such as **Azure Table Storage**.
 
-### Creating a Custom Log Viewer
+### Creating a Custom Log Viewer Repository
 
-To fetch logs from Azure Table Storage, implement the `SerilogLogViewerSourceBase` class from `Umbraco.Cms.Core.Logging.Viewer`.
+To fetch logs from Azure Table Storage, extend the `LogViewerRepositoryBase` class from `Umbraco.Cms.Infrastructure.Services.Implement`.
 
 {% hint style="info" %}
 This implementation requires the `Azure.Data.Tables` NuGet package.
@@ -47,90 +47,118 @@ using Azure;
 using Azure.Data.Tables;
 using Serilog.Events;
 using Serilog.Formatting.Compact.Reader;
-using Serilog.Sinks.AzureTableStorage;
+using Umbraco.Cms.Core.Composing;
 using Umbraco.Cms.Core.Logging.Viewer;
-using ITableEntity = Azure.Data.Tables.ITableEntity;
+using Umbraco.Cms.Core.Serialization;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Infrastructure.Logging.Serilog;
+using Umbraco.Cms.Infrastructure.Services.Implement;
 
 namespace My.Website;
 
-public class AzureTableLogViewer : SerilogLogViewerSourceBase
+public class AzureTableLogsRepository : LogViewerRepositoryBase
 {
-    public AzureTableLogViewer(ILogViewerConfig logViewerConfig, Serilog.ILogger serilogLog, ILogLevelLoader logLevelLoader)
-        : base(logViewerConfig, logLevelLoader, serilogLog)
+    private readonly IJsonSerializer _jsonSerializer;
+
+    public AzureTableLogsRepository(UmbracoFileConfiguration umbracoFileConfig, IJsonSerializer jsonSerializer) : base(
+        umbracoFileConfig)
     {
+        _jsonSerializer = jsonSerializer;
     }
 
-    public override bool CanHandleLargeLogs => true;
-
-    // This method will not be called - as we have indicated that this 'CanHandleLargeLogs'
-    public override bool CheckCanOpenLogs(LogTimePeriod logTimePeriod) => throw new NotImplementedException();
-
-    protected override IReadOnlyList<LogEvent> GetLogs(LogTimePeriod logTimePeriod, ILogFilter filter, int skip, int take)
+    protected override IEnumerable<ILogEntry> GetLogs(LogTimePeriod logTimePeriod, ILogFilter logFilter)
     {
-        //Replace ACCOUNT_NAME and KEY with your actual Azure Storage Account details. The "Logs" parameter refers to the table name where logs will be stored and retrieved from.
+        // This example uses a connetionstring compatible with the Azurite emulator
+        // https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azurite
         var client =
             new TableClient(
-                "DefaultEndpointsProtocol=https;AccountName=ACCOUNT_NAME;AccountKey=KEY;EndpointSuffix=core.windows.net",
-                "Logs");
-
-        // Table storage does not support skip, only take, so the best we can do is to not fetch more entities than we need in total.
-        // See: https://learn.microsoft.com/en-us/rest/api/storageservices/writing-linq-queries-against-the-table-service#returning-the-top-n-entities for more info.
-        var requiredEntities = skip + take;
-        IEnumerable<AzureTableLogEntity> results = client.Query<AzureTableLogEntity>().Take(requiredEntities);
-
-        return results
-            .Skip(skip)
-            .Take(take)
-            .Select(x => LogEventReader.ReadFromString(x.Data))
-            // Filter by timestamp to avoid retrieving all logs from the table, preventing memory and performance issues
-            .Where(evt => evt.Timestamp >= logTimePeriod.StartTime.Date &&
-                evt.Timestamp <= logTimePeriod.EndTime.Date.AddDays(1).AddSeconds(-1))
-            .Where(filter.TakeLogEvent)
-            .ToList();
+                "UseDevelopmentStorage=true",
+                "LogEventEntity");
+
+        // Filter by timestamp to avoid retrieving all logs from the table, preventing memory and performance issues
+        IEnumerable<AzureTableLogEntity> results = client.Query<AzureTableLogEntity>(
+            entity => entity.Timestamp >= logTimePeriod.StartTime.Date &&
+                      entity.Timestamp <= logTimePeriod.EndTime.Date.AddDays(1).AddSeconds(-1));
+
+        // Read the data and apply logfilters
+        IEnumerable<LogEvent> filteredData = results.Select(x => LogEventReader.ReadFromString(x.Data))
+            .Where(logFilter.TakeLogEvent);
+
+        return filteredData.Select(x => new LogEntry
+        {
+            Timestamp = x.Timestamp,
+            Level = Enum.Parse<Core.Logging.LogLevel>(x.Level.ToString()),
+            MessageTemplateText = x.MessageTemplate.Text,
+            Exception = x.Exception?.ToString(),
+            Properties = MapLogMessageProperties(x.Properties),
+            RenderedMessage = x.RenderMessage(),
+        });
     }
 
-    public override IReadOnlyList<SavedLogSearch>? GetSavedSearches()
+    private IReadOnlyDictionary<string, string?> MapLogMessageProperties(
+        IReadOnlyDictionary<string, LogEventPropertyValue>? properties)
     {
-        //This method is optional. If you store saved searches in Azure Table Storage, implement fetching logic here.
-        return base.GetSavedSearches();
+        var result = new Dictionary<string, string?>();
+
+        if (properties is not null)
+        {
+            foreach (KeyValuePair<string, LogEventPropertyValue> property in properties)
+            {
+                string? value;
+
+                if (property.Value is ScalarValue scalarValue)
+                {
+                    value = scalarValue.Value?.ToString();
+                }
+                else if (property.Value is StructureValue structureValue)
+                {
+                    var textWriter = new StringWriter();
+                    structureValue.Render(textWriter);
+                    value = textWriter.ToString();
+                }
+                else
+                {
+                    value = _jsonSerializer.Serialize(property.Value);
+                }
+
+                result.Add(property.Key, value);
+            }
+        }
+
+        return result;
     }
 
-    public override IReadOnlyList<SavedLogSearch>? AddSavedSearch(string? name, string? query)
+    public class AzureTableLogEntity : ITableEntity
     {
-        //This method is optional. If you store saved searches in Azure Table Storage, implement adding logic here.
-        return base.AddSavedSearch(name, query);
-    }
+        public required string Data { get; set; }
 
-    public override IReadOnlyList<SavedLogSearch>? DeleteSavedSearch(string? name, string? query)
-    {
-        //This method is optional. If you store saved searches in Azure Table Storage, implement deleting logic here.
-        return base.DeleteSavedSearch(name, query);
-    }
-}
+        public required string PartitionKey { get; set; }
 
-public class AzureTableLogEntity : LogEventEntity, ITableEntity
-{
-    public DateTimeOffset? Timestamp { get; set; }
+        public required string RowKey { get; set; }
 
-    public ETag ETag { get; set; }
+        public DateTimeOffset? Timestamp { get; set; }
+
+        public ETag ETag { get; set; }
+    }
 }
 ```
 
-Azure Table Storage requires entities to implement the `ITableEntity` interface. Since Umbraco’s default log entity does not implement this, a custom entity (`AzureTableLogEntity`) must be created to ensure logs are correctly fetched and stored.
+Azure Table Storage requires entities to implement the `ITableEntity` interface. Since Umbraco’s default log entity does not implement this, a custom entity (`AzureTableLogEntity`) must be created to ensure logs are correctly fetched.
 
 ### Register implementation
 
-Umbraco needs to be made aware that there is a new implementation of an `ILogViewer` to register. We also need to replace the default JSON LogViewer that we ship in the core of Umbraco.
+Umbraco needs to be made aware that there is a new implementation of an `ILogViewerRepository` to register. We also need to replace the default JSON LogViewer that is shipped in the core of Umbraco.
 
 ```csharp
 using Umbraco.Cms.Core.Composing;
 using Umbraco.Cms.Infrastructure.DependencyInjection;
 
 namespace My.Website;
 
-public class LogViewerSavedSearches : IComposer
-{
-    public void Compose(IUmbracoBuilder builder) => builder.SetLogViewer<AzureTableLogViewer>();
+public class AzureTableLogsComposer : IComposer
+    {
+        public void Compose(IUmbracoBuilder builder) => builder.Services.AddUnique<ILogViewerRepository, AzureTableLogsRepository>();
+    }
 }
 ```
 

16/umbraco-cms/fundamentals/code/debugging/logging.md

@@ -117,6 +117,10 @@ Serilog uses levels as the primary means for assigning importance to log events.
 
 Serilog can be configured and extended by using the .NET Core configuration such as the AppSetting.json files or environment variables. For more information, see the [Serilog config](../../../reference/configuration/serilog.md) article.
 
+## The UmbracoFile Sink
+
+Serilog uses the concept of Sinks to output the log messages to different places. Umbraco ships with a custom sink configuration called UmbracoFile that uses the [Serilog.Sinks.File](https://github.com/serilog/serilog-sinks-file) sink to save the logs to a rolling file on disk in the Umbraco. You can disable this sink by setting its Enabled configuration flag to false, see [Serilog config](../../../reference/configuration/serilog.md) for more information.
+
 ## The logviewer dashboard
 
 Learn more about the [logviewer dashboard](../../backoffice/logviewer.md) in the backoffice and how it can be extended.

16/umbraco-cms/reference/configuration/serilog.md

@@ -105,6 +105,7 @@ By default, Umbraco uses a special Serilog 'sink' that is optimized for performa
       {
         "Name": "UmbracoFile",
         "Args": {
+          "Enabled": "True",
           "RestrictedToMinimumLevel": "Warning",
           "FileSizeLimitBytes": 1073741824,
           "RollingInterval" : "Day",
@@ -117,6 +118,8 @@ By default, Umbraco uses a special Serilog 'sink' that is optimized for performa
   }
 ```
 
+You can also disable this sink if you do not wish to write files to disk.
+
 ## Adding a custom log property to all log items
 
 You may wish to add a log property to all log messages. A good example could be a log property for the `environment` to determine if the log message came from `development` or `production`.