New major version of Log Exporter app

Apps/LogExporterApp/AppConfig.cs

@@ -19,69 +19,153 @@ You should have received a copy of the GNU General Public License
 */
 
 using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using TechnitiumLibrary.Net.Dns;
+using static LogExporter.SinkConfig;
 
 namespace LogExporter
 {
     public class AppConfig
     {
-        [JsonPropertyName("maxQueueSize")]
-        public int MaxQueueSize { get; set; }
+        [JsonPropertyName("sinks")]
+        public SinkConfig Sinks { get; set; }
+
+        [JsonPropertyName("pipeline")]
+        public PipelineConfig Pipeline { get; set; }
+
+        /// <summary>
+        /// Loads config and enforces DataAnnotations validation.
+        ///<para>
+        /// ADR: Validation is intentionally centralized here so that:
+        ///   - App receives only a fully valid configuration.
+        ///   - Errors surface early with domain-specific messages.
+        ///   - No runtime failures occur deep inside the logging pipeline.
+        /// This ensures plugin initialization is deterministic and safe.
+        /// </para>
+        /// </summary>
+        public static AppConfig Deserialize(string json)
+        {
+            AppConfig config = JsonSerializer.Deserialize<AppConfig>(json, DnsConfigSerializerOptions.Default)
+                         ?? throw new DnsClientException("Configuration could not be deserialized.");
 
-        [JsonPropertyName("enableEdnsLogging ")]
-        public bool EnableEdnsLogging { get; set; }
+            ValidateObject(config);
 
-        [JsonPropertyName("file")]
-        public FileTarget? FileTarget { get; set; }
+            // Validate enabled targets only — disabled ones may be incomplete by design.
 
-        [JsonPropertyName("http")]
-        public HttpTarget? HttpTarget { get; set; }
+            if (config.Sinks.FileSinkConfig?.Enabled is true)
+                ValidateObject(config.Sinks.FileSinkConfig);
 
-        [JsonPropertyName("syslog")]
-        public SyslogTarget? SyslogTarget { get; set; }
+            if (config.Sinks.HttpSinkConfig?.Enabled is true)
+                ValidateObject(config.Sinks.HttpSinkConfig);
+
+            if (config.Sinks.SyslogSinkConfig?.Enabled is true)
+                ValidateObject(config.Sinks.SyslogSinkConfig);
 
-        // Load configuration from JSON
-        public static AppConfig? Deserialize(string json)
+            return config;
+        }
+
+        private static void ValidateObject(object instance)
         {
-            return JsonSerializer.Deserialize<AppConfig>(json, DnsConfigSerializerOptions.Default);
+            ValidationContext ctx = new ValidationContext(instance);
+            Validator.ValidateObject(instance, ctx, validateAllProperties: true);
         }
     }
-
-    public class TargetBase
+    public class FeatureBase
     {
         [JsonPropertyName("enabled")]
-        public bool Enabled { get; set; }
+        public bool Enabled { get; set; } = true;
     }
 
-    public class SyslogTarget : TargetBase
+    public class SinkConfig
     {
-        [JsonPropertyName("address")]
-        public required string Address { get; set; }
+        [Range(1, int.MaxValue, ErrorMessage = "maxQueueSize must be greater than zero.")]
 
-        [JsonPropertyName("port")]
-        public int? Port { get; set; }
+        [JsonPropertyName("maxQueueSize")]
+        public int MaxQueueSize { get; set; } = int.MaxValue;
 
-        [JsonPropertyName("protocol")]
-        public string? Protocol { get; set; }
-    }
+        [JsonPropertyName("enableEdnsLogging")]
+        public bool EnableEdnsLogging { get; set; } = true;
 
-    public class FileTarget : TargetBase
-    {
-        [JsonPropertyName("path")]
-        public required string Path { get; set; }
+        [JsonPropertyName("console")]
+        public ConsoleSink ConsoleSinkConfig { get; set; }
+
+        [JsonPropertyName("file")]
+        public FileSink FileSinkConfig { get; set; }
+
+        [JsonPropertyName("http")]
+        public HttpSink HttpSinkConfig { get; set; }
+
+        [JsonPropertyName("syslog")]
+        public SyslogSink SyslogSinkConfig { get; set; }
+
+        public class SyslogSink : FeatureBase
+        {
+            [Required(ErrorMessage = "syslog.address is required when syslog logging is enabled.")]
+            [JsonPropertyName("address")]
+            public string Address { get; set; }
+
+            [Range(1, 65535)]
+            [JsonPropertyName("port")]
+            public int? Port { get; set; }
+
+            [AllowedValues(["UDP", "TCP", "TLS", "LOCAL"])]
+            [JsonPropertyName("protocol")]
+            public string Protocol { get; set; }
+        }
+
+        public class ConsoleSink : FeatureBase
+        {
+        }
+
+        public class FileSink : FeatureBase
+        {
+            [Required(ErrorMessage = "file.path is required when syslog logging is enabled.")]
+            [JsonPropertyName("path")]
+            public string Path { get; set; }
+        }
+
+        public class HttpSink : FeatureBase
+        {
+
+            [Required(ErrorMessage = "http.endpoint is required when HTTP logging is enabled.")]
+            [Url]
+            [JsonPropertyName("endpoint")]
+            public string Endpoint { get; set; }
+
+            [JsonPropertyName("headers")]
+            public Dictionary<string, string?>? Headers { get; set; }
+
+            [JsonPropertyName("ndjson")]
+            public bool NdJson { get; set; } = true;
+        }
     }
 
-    public class HttpTarget : TargetBase
+    public class PipelineConfig
     {
-        [JsonPropertyName("endpoint")]
-        public required string Endpoint { get; set; }
+        [JsonPropertyName("normalize")]
+        public NormalizeProcess NormalizeProcessConfig { get; set; }
 
-        [JsonPropertyName("headers")]
-        public Dictionary<string, string?>? Headers { get; set; }
-    }
+        [JsonPropertyName("tagging")]
+        public TaggingProcess TaggingProcessConfig {  get; set; }
 
-    // Setup reusable options with a single instance
+        public class NormalizeProcess : FeatureBase
+        {}
+
+        public class TaggingProcess : FeatureBase
+        {
+            [Required(ErrorMessage = "tags are required when tagging is enabled.")]
+            [JsonPropertyName("tags")]
+            public List<string> Tags { get; set; } = new List<string>();
+        }
+
+    }
+    /// <summary>
+    /// Shared serializer configuration for reading dnsApp.config.
+    /// ADR: The serializer options are centralized so that parsing behavior
+    /// is stable and predictable across the entire plugin lifetime.
+    /// </summary>
     public static class DnsConfigSerializerOptions
     {
         public static readonly JsonSerializerOptions Default = new JsonSerializerOptions

Apps/LogExporterApp/LogEntry.cs

@@ -1,4 +1,4 @@
-/*
+/*
 Technitium DNS Server
 Copyright (C) 2025  Shreyas Zare (shreyas@technitium.com)
 Copyright (C) 2025  Zafer Balkan (zafer@zaferbalkan.com)
@@ -14,10 +14,9 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
+along with this program.  If not, see <http://www.gnu.org/licenses/>
 
 */
-
 using DnsServerCore.ApplicationCommon;
 using System;
 using System.Collections.Generic;
@@ -33,11 +32,18 @@ namespace LogExporter
 {
     public class LogEntry
     {
+        // Reuse empty lists to avoid allocations when there are no answers or EDNS data
+        private static readonly DnsResourceRecord[] EmptyAnswers = Array.Empty<DnsResourceRecord>();
+        private static readonly EDNSLog[] EmptyEdns = Array.Empty<EDNSLog>();
+
         public LogEntry(DateTime timestamp, IPEndPoint remoteEP, DnsTransportProtocol protocol, DnsDatagram request, DnsDatagram response, bool ednsLogging = false)
         {
             // Assign timestamp and ensure it's in UTC
             Timestamp = timestamp.Kind == DateTimeKind.Utc ? timestamp : timestamp.ToUniversalTime();
 
+            // Set hostname
+            NameServer = request.Metadata.NameServer.Host;
+
             // Extract client information
             ClientIp = remoteEP.Address.ToString();
             Protocol = protocol;
@@ -61,48 +67,108 @@ public LogEntry(DateTime timestamp, IPEndPoint remoteEP, DnsTransportProtocol pr
                 };
             }
 
-            // Convert answer section into a simple string summary (comma-separated for multiple answers)
-            Answers = new List<DnsResourceRecord>(response.Answer.Count);
+            // Convert answer section - reuse empty list when no answers
             if (response.Answer.Count > 0)
             {
-                Answers.AddRange(response.Answer.Select(record => new DnsResourceRecord
-                {
-                    Name = record.Name,
-                    RecordType = record.Type,
-                    RecordClass = record.Class,
-                    RecordTtl = record.TTL,
-                    RecordData = record.RDATA.ToString(),
-                    DnssecStatus = record.DnssecStatus,
-                }));
+                Answers = new List<DnsResourceRecord>(
+                    response.Answer.Select(record => new DnsResourceRecord
+                    {
+                        Name = record.Name,
+                        RecordType = record.Type,
+                        RecordClass = record.Class,
+                        RecordTtl = record.TTL,
+                        RecordData = record.RDATA.ToString(),
+                        DnssecStatus = record.DnssecStatus,
+                    })).ToArray();
             }
+            else
+            {
+                Answers = EmptyAnswers;
+            }
+
+            PopulateEDNSLogs(response, ednsLogging);
+        }
 
-            EDNS = new List<EDNSLog>();
+        private void PopulateEDNSLogs(DnsDatagram response, bool ednsLogging)
+        {
+            // Handle EDNS - reuse empty list when no EDNS logging or no errors
             if (!ednsLogging || response.EDNS is null)
             {
+                EDNS = EmptyEdns;
+                return;
+            }
+
+            List<EDnsOption> ednsErrors = response.EDNS.Options.Where(o => o.Code == EDnsOptionCode.EXTENDED_DNS_ERROR).ToList();
+            if (ednsErrors.Count == 0)
+            {
+                EDNS = EmptyEdns;
                 return;
             }
 
-            foreach (EDnsOption extendedErrorLog in response.EDNS.Options.Where(o => o.Code == EDnsOptionCode.EXTENDED_DNS_ERROR))
+            List<EDNSLog> edns = new List<EDNSLog>(ednsErrors.Count);
+            foreach (EDnsOption extendedErrorLog in ednsErrors)
             {
-                string[] extractedData = extendedErrorLog.Data.ToString().Replace("[", string.Empty).Replace("]", string.Empty).Split(":", StringSplitOptions.TrimEntries);
+                // ADR: EDNS extended error comes from network input and may not follow
+                // the expected "type: message" format. Previously this code assumed
+                // a well-formed structure and could throw IndexOutOfRangeException,
+                // allowing remote parties to crash the logging pipeline.
+                // We now parse defensively and treat malformed data as a best-effort message.
+
+                string? raw = extendedErrorLog.Data?.ToString();
+                if (string.IsNullOrWhiteSpace(raw))
+                    continue;
+
+                raw = raw.Replace("[", "").Replace("]", "");
+
+                string? errType = null;
+                string? message = null;
 
-                EDNS.Add(new EDNSLog
+                string[] parts = raw.Split(':', 2, StringSplitOptions.TrimEntries);
+                if (parts.Length == 2)
                 {
-                    ErrType = extractedData[0],
-                    Message = extractedData[1]
+                    errType = parts[0];
+                    message = parts[1];
+                }
+                else
+                {
+                    // fallback: treat the raw payload as the message
+                    message = raw;
+                }
+
+                edns.Add(new EDNSLog
+                {
+                    ErrType = errType,
+                    Message = message
                 });
             }
+
+            // If no valid EDNS entries were added, use the empty list
+            EDNS = edns.Count == 0 ? EmptyEdns : edns.ToArray();
         }
 
-        public List<DnsResourceRecord> Answers { get; private set; }
-        public string ClientIp { get; private set; }
-        public List<EDNSLog> EDNS { get; private set; }
-        public DnsTransportProtocol Protocol { get; private set; }
-        public DnsQuestion? Question { get; private set; }
-        public DnsResponseCode ResponseCode { get; private set; }
+        public DnsResourceRecord[] Answers { get; }
+
+        public string ClientIp { get; }
+
+        public EDNSLog[] EDNS { get; private set; }
+
+        public string NameServer { get; }
+
+        public DnsTransportProtocol Protocol { get; }
+
+        public DnsQuestion? Question { get; }
+
+        public DnsResponseCode ResponseCode { get; }
+
         public double? ResponseRtt { get; private set; }
-        public DnsServerResponseType ResponseType { get; private set; }
-        public DateTime Timestamp { get; private set; }
+
+        public DnsServerResponseType ResponseType { get; }
+
+        public DateTime Timestamp { get; }
+
+        // Meta bag populated by pipeline stages
+        public Dictionary<string, object> Meta { get; } = new();
+
         public override string ToString()
         {
             return JsonSerializer.Serialize(this, DnsLogSerializerOptions.Default);
@@ -124,16 +190,16 @@ public static class DnsLogSerializerOptions
         public class DnsQuestion
         {
             public DnsClass QuestionClass { get; set; }
-            public required string QuestionName { get; set; }
+            public string QuestionName { get; set; }
             public DnsResourceRecordType QuestionType { get; set; }
         }
 
         public class DnsResourceRecord
         {
             public DnssecStatus DnssecStatus { get; set; }
-            public required string Name { get; set; }
+            public string Name { get; set; }
             public DnsClass RecordClass { get; set; }
-            public required string RecordData { get; set; }
+            public string RecordData { get; set; }
             public uint RecordTtl { get; set; }
             public DnsResourceRecordType RecordType { get; set; }
         }