diff --git a/src/Seq.App.EmailPlus/DeliveryType.cs b/src/Seq.App.EmailPlus/DeliveryType.cs
new file mode 100644
index 0000000..ae985a5
--- /dev/null
+++ b/src/Seq.App.EmailPlus/DeliveryType.cs
@@ -0,0 +1,12 @@
+namespace Seq.App.EmailPlus
+{
+    public enum DeliveryType
+    {
+        MailHost,
+        MailFallback,
+        Dns,
+        DnsFallback,
+        HostDnsFallback,
+        None = -1
+    }
+}
diff --git a/src/Seq.App.EmailPlus/DirectMailGateway.cs b/src/Seq.App.EmailPlus/DirectMailGateway.cs
index 17a2c7f..b0a0ace 100644
--- a/src/Seq.App.EmailPlus/DirectMailGateway.cs
+++ b/src/Seq.App.EmailPlus/DirectMailGateway.cs
@@ -1,5 +1,9 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
+using DnsClient;
+using DnsClient.Protocol;
 using MailKit.Net.Smtp;
 using MimeKit;
 
@@ -7,17 +11,192 @@ namespace Seq.App.EmailPlus
 {
     class DirectMailGateway : IMailGateway
     {
-        public async Task SendAsync(SmtpOptions options, MimeMessage message)
+        static readonly SmtpClient Client = new SmtpClient();
+        static readonly LookupClient DnsClient = new LookupClient();
+
+        public async Task<MailResult> SendAsync(SmtpOptions options, MimeMessage message)
+        {
+            if (message == null) throw new ArgumentNullException(nameof(message));
+            var mailResult = new MailResult();
+            var type = DeliveryType.MailHost;
+            var errors = new List<Exception>();
+            foreach (var server in options.Host)
+            {
+                mailResult = await TryDeliver(server, options, message, type);
+                if (!mailResult.Success)
+                {
+                    errors.Add(mailResult.LastError);
+                    type = DeliveryType.MailFallback;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            mailResult.Errors = errors;
+            return mailResult;
+        }
+
+        public async Task<DnsMailResult> SendDnsAsync(DeliveryType deliveryType, SmtpOptions options,
+            MimeMessage message)
         {
+            var dnsResult = new DnsMailResult();
+            var resultList = new List<MailResult>();
+            var lastServer = string.Empty;
+            var errors = new List<Exception>();
             if (message == null) throw new ArgumentNullException(nameof(message));
+            var type = deliveryType;
+
+            try
+            {
+                var domains = GetDomains(message).ToList();
+                var successCount = 0;
+
+                foreach (var domain in domains)
+                {
+                    type = deliveryType;
+                    lastServer = domain;
+                    var mx = await DnsClient.QueryAsync(domain, QueryType.MX);
+                    var mxServers =
+                        (from mxServer in mx.Answers
+                            where !string.IsNullOrEmpty(((MxRecord)mxServer).Exchange)
+                            select ((MxRecord)mxServer).Exchange).Select(dummy => (string)dummy).ToList();
+                    var mailResult = new MailResult();
+                    foreach (var server in mxServers)
+                    {
+                        lastServer = server;
+                        mailResult = await TryDeliver(server, options, message, type);
+                        var lastError = dnsResult.LastError;
+                        errors.AddRange(mailResult.Errors);
+
+                        dnsResult = new DnsMailResult
+                        {
+                            LastServer = server,
+                            LastError = mailResult.LastError ?? lastError,
+                            Type = type,
+                        };
+
+                        resultList.Add(mailResult);
+
+                        if (mailResult.Success)
+                            break;
+                        type = DeliveryType.DnsFallback;
+                    }
+
+                    if (mailResult.Success)
+                    {
+                        successCount++;
+                        continue;
+                    }
+
+                    if (dnsResult.LastError != null) continue;
+                    dnsResult.LastError = mxServers.Count == 0
+                        ? new Exception("DNS delivery failed - no MX records detected for " + domain)
+                        : new Exception("DNS delivery failed - no error detected");
+                    dnsResult.Success = false;
+                    dnsResult.Errors.Add(dnsResult.LastError);
+                }
+
+                if (!domains.Any())
+                {
+                    dnsResult.Success = false;
+                    dnsResult.LastError =
+                        new Exception("DNS delivery failed - no domains parsed from recipient addresses");
+                }
+
+                if (successCount < domains.Count)
+                {
+                    if (successCount == 0)
+                    {
+                        dnsResult.Success = false;
+                        dnsResult.LastError =
+                            new Exception("DNS delivery failure - no domains could be successfully delivered.");
+                    }
+                    else
+                    {
+                        dnsResult.Success = true; // A qualified success ...
+                        dnsResult.LastError =
+                            new Exception(
+                                $"DNS delivery partial failure - {domains.Count - successCount} of {successCount} domains could not be delivered.");
+                    }
+
+                    dnsResult.Errors.Add(dnsResult.LastError);
+                }
+                else
+                {
+                    dnsResult.Success = true;
+                }
+            }
+            catch (Exception ex)
+            {
+                dnsResult = new DnsMailResult
+                {
+                    Type = type,
+                    LastServer = lastServer,
+                    Success = false,
+                    LastError = ex
+                };
+            }
+
+            dnsResult.Errors = errors;
+            dnsResult.Results = resultList;
+            return dnsResult;
+        }
+
+
+        public static IEnumerable<string> GetDomains(MimeMessage message)
+        {
+            var domains = new List<string>();
+            foreach (var to in message.To)
+            {
+                var toDomain = to.ToString().Split('@')[1];
+                if (string.IsNullOrEmpty(toDomain)) continue;
+                if (!domains.Any(domain => domain.Equals(toDomain, StringComparison.OrdinalIgnoreCase)))
+                    domains.Add(toDomain);
+            }
+
+            foreach (var cc in message.Cc)
+            {
+                var ccDomain = cc.ToString().Split('@')[1];
+                if (string.IsNullOrEmpty(ccDomain)) continue;
+                if (!domains.Any(domain => domain.Equals(ccDomain, StringComparison.OrdinalIgnoreCase)))
+                    domains.Add(ccDomain);
+            }
+
+            
+            foreach (var bcc in message.Bcc)
+            {
+                var bccDomain = bcc.ToString().Split('@')[1];
+                if (string.IsNullOrEmpty(bccDomain)) continue;
+                if (!domains.Any(domain => domain.Equals(bccDomain, StringComparison.OrdinalIgnoreCase)))
+                    domains.Add(bccDomain);
+            }
+
+            return domains;
+        }
+
+        private static async Task<MailResult> TryDeliver(string server, SmtpOptions options, MimeMessage message,
+            DeliveryType deliveryType)
+        {
+            if (string.IsNullOrEmpty(server))
+                return new MailResult {Success = false, LastServer = server, Type = deliveryType};
+            try
+            {
+                await Client.ConnectAsync(server, options.Port, options.SocketOptions);
+                if (options.RequiresAuthentication)
+                    await Client.AuthenticateAsync(options.Username, options.Password);
+
+
+                await Client.SendAsync(message);
+                await Client.DisconnectAsync(true);
 
-            var client = new SmtpClient();
-                
-            await client.ConnectAsync(options.Host, options.Port, options.SocketOptions);
-            if (options.RequiresAuthentication)
-                await client.AuthenticateAsync(options.Username, options.Password);
-            await client.SendAsync(message);
-            await client.DisconnectAsync(true);
+                return new MailResult {Success = true, LastServer = server, Type = deliveryType};
+            }
+            catch (Exception ex)
+            {
+                return new MailResult {Success = false, LastError = ex, LastServer = server, Type = deliveryType};
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.App.EmailPlus/DnsMailResult.cs b/src/Seq.App.EmailPlus/DnsMailResult.cs
new file mode 100644
index 0000000..3fc296d
--- /dev/null
+++ b/src/Seq.App.EmailPlus/DnsMailResult.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+// ReSharper disable UnusedAutoPropertyAccessor.Global
+
+namespace Seq.App.EmailPlus
+{
+    public class DnsMailResult
+    {
+        public bool Success { get; set; }
+        public DeliveryType Type { get; set; }
+        public string LastServer { get; set; }
+        public Exception LastError { get; set; }
+        public List<Exception> Errors { get; set; } = new List<Exception>();
+        public List<MailResult> Results { get; set; } = new List<MailResult>();
+    }
+}
diff --git a/src/Seq.App.EmailPlus/EmailApp.cs b/src/Seq.App.EmailPlus/EmailApp.cs
index 03d0569..21079ae 100644
--- a/src/Seq.App.EmailPlus/EmailApp.cs
+++ b/src/Seq.App.EmailPlus/EmailApp.cs
@@ -4,10 +4,11 @@
 using System.Linq;
 using System.Threading.Tasks;
 using HandlebarsDotNet;
-using MailKit.Security;
 using MimeKit;
 using Seq.Apps;
 using Seq.Apps.LogEvents;
+using System.Timers;
+using Timer = System.Timers.Timer;
 
 // ReSharper disable UnusedAutoPropertyAccessor.Global, MemberCanBePrivate.Global
 
@@ -16,19 +17,36 @@ namespace Seq.App.EmailPlus
     using Template = HandlebarsTemplate<object, object>;
 
     [SeqApp("HTML Email",
-        Description = "Uses Handlebars templates to format events and notifications into HTML email.")]
+        Description =
+            "Uses Handlebars templates to format events and notifications into HTML email, with optional alternate plain text body.")]
     public class EmailApp : SeqApp, ISubscribeToAsync<LogEventData>
     {
         readonly IMailGateway _mailGateway;
         readonly IClock _clock;
         readonly Dictionary<uint, DateTime> _suppressions = new Dictionary<uint, DateTime>();
-        readonly Lazy<Template> _bodyTemplate, _subjectTemplate, _toAddressesTemplate;
+
+        readonly Lazy<Template> _bodyTemplate,
+            _plainTextTemplate,
+            _subjectTemplate,
+            _toAddressesTemplate,
+            _replyToAddressesTemplate,
+            _ccAddressesTemplate,
+            _bccAddressesTemplate;
+
         readonly Lazy<SmtpOptions> _options;
+        private readonly object _sync = new object();
+        readonly List<Event<LogEventData>> _waiting = new List<Event<LogEventData>>();
+
+        Timer _timer;
+        TimeSpan _batchSend = TimeSpan.Zero;
+        int _batchItems;
 
         const string DefaultSubjectTemplate = @"[{{$Level}}] {{{$Message}}} (via Seq)";
         const int MaxSubjectLength = 130;
         const int DefaultPort = 25;
         const int DefaultSslPort = 465;
+        const int DefaultBatchSizeLimit = 50;
+
 
         static EmailApp()
         {
@@ -41,15 +59,16 @@ internal EmailApp(IMailGateway mailGateway, IClock clock)
             _clock = clock ?? throw new ArgumentNullException(nameof(clock));
 
             var port = Port ?? DefaultPort;
-            _options = _options = new Lazy<SmtpOptions>(() => new SmtpOptions(
+            _options = new Lazy<SmtpOptions>(() => new SmtpOptions(
                 Host,
-                port, 
-                EnableSsl ?? false
-                    ? RequireSslForPort(port)
-                    : SecureSocketOptions.StartTlsWhenAvailable, 
+                DeliverUsingDns != null && (bool)DeliverUsingDns,
+                port,
+                Priority,
+                DefaultPriority,
+                SmtpOptions.GetSocketOptions(port, EnableSsl, UseTlsWhenAvailable),
                 Username,
                 Password));
-            
+
             _subjectTemplate = new Lazy<Template>(() =>
             {
                 var subjectTemplate = SubjectTemplate;
@@ -62,22 +81,55 @@ internal EmailApp(IMailGateway mailGateway, IClock clock)
             {
                 var bodyTemplate = BodyTemplate;
                 if (string.IsNullOrEmpty(bodyTemplate))
-                    bodyTemplate = Resources.DefaultBodyTemplate;
+                {
+                    bodyTemplate = BatchTimeInSeconds > 0
+                        ? Resources.DigestBodyTemplate
+                        : Resources.DefaultBodyTemplate;
+                }
+
                 return Handlebars.Compile(bodyTemplate);
             });
 
+            _plainTextTemplate = new Lazy<Template>(() =>
+            {
+                var plainTextTemplate = PlainTextTemplate;
+                if (string.IsNullOrEmpty(plainTextTemplate))
+                {
+                    plainTextTemplate = BatchTimeInSeconds > 0
+                        ? Resources.DigestBodyTemplate
+                        : Resources.DefaultBodyTemplate;
+                }
+
+                return Handlebars.Compile(plainTextTemplate);
+            });
+
             _toAddressesTemplate = new Lazy<Template>(() =>
             {
                 var toAddressTemplate = To;
-                if (string.IsNullOrEmpty(toAddressTemplate))
-                    return (_, __) => To;
-                return Handlebars.Compile(toAddressTemplate);
+                return string.IsNullOrEmpty(toAddressTemplate) ? (_, __) => To : Handlebars.Compile(toAddressTemplate);
             });
-        }
 
-        internal static SecureSocketOptions RequireSslForPort(int port)
-        {
-            return (port == DefaultSslPort ? SecureSocketOptions.SslOnConnect : SecureSocketOptions.StartTls);
+            _replyToAddressesTemplate = new Lazy<Template>(() =>
+            {
+                var replyToAddressTemplate = ReplyTo;
+                return string.IsNullOrEmpty(replyToAddressTemplate)
+                    ? (_, __) => ReplyTo
+                    : Handlebars.Compile(replyToAddressTemplate);
+            });
+
+            _ccAddressesTemplate = new Lazy<Template>(() =>
+            {
+                var ccAddressTemplate = Cc;
+                return string.IsNullOrEmpty(ccAddressTemplate) ? (_, __) => Cc : Handlebars.Compile(ccAddressTemplate);
+            });
+
+            _bccAddressesTemplate = new Lazy<Template>(() =>
+            {
+                var bccAddressTemplate = Bcc;
+                return string.IsNullOrEmpty(bccAddressTemplate)
+                    ? (_, __) => Bcc
+                    : Handlebars.Compile(bccAddressTemplate);
+            });
         }
 
         public EmailApp()
@@ -92,46 +144,131 @@ public EmailApp()
 
         [SeqAppSetting(
             DisplayName = "To address",
-            HelpText = "The account to which the email is being sent. Multiple addresses are separated by a comma. Handlebars syntax is supported.")]
+            HelpText =
+                "The account to which the email is being sent. Multiple addresses are separated by a comma. Handlebars syntax is supported (unless Digest batch time is configured).")]
         public string To { get; set; }
 
+        [SeqAppSetting(
+            DisplayName = "ReplyTo address",
+            HelpText =
+                "Optional account to which replies will be sent. Multiple addresses are separated by a comma. Handlebars syntax is supported (unless Digest batch time is configured).",
+            IsOptional = true)]
+        public string ReplyTo { get; set; }
+
+        [SeqAppSetting(
+            DisplayName = "CC address",
+            HelpText =
+                "Optional account to which emails should be sent as CC. Multiple addresses are separated by a comma. Handlebars syntax is supported (unless Digest batch time is configured).",
+            IsOptional = true)]
+        public string Cc { get; set; }
+
+        [SeqAppSetting(
+            DisplayName = "BCC address",
+            HelpText =
+                "Optional account to which the email is being sent as BCC. Multiple addresses are separated by a comma. Handlebars syntax is supported (unless Digest batch time is configured).",
+            IsOptional = true)]
+        public string Bcc { get; set; }
+
         [SeqAppSetting(
             IsOptional = true,
             DisplayName = "Subject template",
-            HelpText = "The subject of the email, using Handlebars syntax. If blank, a default subject will be generated.")]
+            HelpText =
+                "The subject of the email, using Handlebars syntax. If blank, a default subject will be generated.")]
         public string SubjectTemplate { get; set; }
 
         [SeqAppSetting(
-            HelpText = "The name of the SMTP server machine.")]
+            DisplayName = "SMTP Mail Host(s)",
+            HelpText =
+                "The name of the SMTP server machine. Optionally specify fallback hosts as comma-delimited string. If not specified, Deliver Using DNS should be enabled.",
+            IsOptional = true)]
         public new string Host { get; set; }
 
+        [SeqAppSetting(
+            DisplayName = "Deliver using DNS",
+            HelpText =
+                "Deliver directly using DNS. If SMTP Mail Host(s) is configured, this will be used as a fallback delivery mechanism. If not enabled, SMTP Mail Host(s) should be configured.")]
+        public bool? DeliverUsingDns { get; set; }
+
         [SeqAppSetting(
             IsOptional = true,
-            HelpText = "The port on the SMTP server machine to send mail to. Leave this blank to use the standard port (25).")]
+            HelpText =
+                "The port on the SMTP server machine to send mail to. Leave this blank to use the standard port (25).")]
         public int? Port { get; set; }
 
         [SeqAppSetting(
             IsOptional = true,
             DisplayName = "Require TLS",
-            HelpText = "Check this box to require that the server supports SSL/TLS for sending messages. If the port used is 465," +
-                       "implicit SSL will be enabled; otherwise, the STARTTLS extension will be used.")]
+            HelpText =
+                "Check this box to require that the server supports SSL/TLS for sending messages. If the port used is 465," +
+                "implicit SSL will ALWAYS be enabled; otherwise, the STARTTLS extension will be used if Require TLS is enabled. If this is disabled, Use Optional TLS If Available can be configured to allow TLS to be used when offered.")]
         public bool? EnableSsl { get; set; }
 
+        [SeqAppSetting(
+            IsOptional = true,
+            DisplayName = "Use Optional TLS if available",
+            HelpText =
+                "If Enable SSL is disabled but the host supports TLS, allow Seq to negotiate using TLS. This has no effect if Enable SSL is enabled.")]
+        public bool? UseTlsWhenAvailable { get; set; }
+
         [SeqAppSetting(
             IsOptional = true,
             InputType = SettingInputType.LongText,
             DisplayName = "Body template",
-            HelpText = "The template to use when generating the email body, using Handlebars syntax. Leave this blank to use " +
-                       "the default template that includes the message and " +
-                       "properties (https://github.com/datalust/seq-app-htmlemail/blob/main/src/Seq.App.EmailPlus/Resources/DefaultBodyTemplate.html).")]
+            HelpText =
+                "The template to use when generating the email body, using Handlebars syntax. Leave this blank to use " +
+                "the default template that includes the message and " +
+                "properties (https://github.com/datalust/seq-app-htmlemail/blob/main/src/Seq.App.EmailPlus/Resources/DefaultBodyTemplate.html, or https://github.com/datalust/seq-app-htmlemail/tree/master/src/Seq.App.EmailPlus/Resources/DigestBodyTemplate.html if Digest batch time is configured).")]
         public string BodyTemplate { get; set; }
 
+        [SeqAppSetting(
+            IsOptional = true,
+            InputType = SettingInputType.LongText,
+            DisplayName = "Plain text template",
+            HelpText =
+                "Optional plain text template to use when generating the email body, using Handlebars.NET syntax. Leave this blank to disable.")]
+        public string PlainTextTemplate { get; set; }
+
+        [SeqAppSetting(
+            IsOptional = true,
+            DisplayName = "Email Priority Property",
+            HelpText =
+                "Event Property that can be used to map email priority; properties can be mapped to email priority using the Email Priority or Property Mapping field. Will not be used if Digest batch time is configured.")]
+        public string PriorityProperty { get; set; }
+
+        [SeqAppSetting(
+            IsOptional = true,
+            DisplayName = "Email Priority or Property Mapping",
+            HelpText =
+                "The Priority of the email - High, Normal, Low - Default Normal, or 'Email Priority Property' mapping using Property=Mapping format, eg. Highest=High,Error=Normal,Low=Low. Property mapping will not be used if Digest batch time is configured.")]
+        public string Priority { get; set; }
+
+        [SeqAppSetting(
+            IsOptional = true,
+            DisplayName = "Default Priority",
+            HelpText =
+                "If using Email Priority mapping - Default for events not matching the mapping - High, Normal, or Low. Defaults to Normal.")]
+        public string DefaultPriority { get; set; }
+
         [SeqAppSetting(
             DisplayName = "Suppression time (minutes)",
             IsOptional = true,
             HelpText = "Once an event type has been sent, the time to wait before sending again. The default is zero.")]
         public int SuppressionMinutes { get; set; }
 
+        [SeqAppSetting(
+            IsOptional = true,
+            DisplayName = "Digest batch time (seconds)",
+            HelpText =
+                "Optional digest. If greater than 0, enables timed batches - Wait N seconds before sending an email batch. Default is 0.")]
+        public int? BatchTimeInSeconds { get; set; }
+
+        [SeqAppSetting(
+            IsOptional = true,
+            DisplayName = "Maximum digest batch size",
+            HelpText =
+                "Optional digest. If Batch time is set, maximum number of events to package into a single batch. If not specified, the default limit of 50 will be applied.")]
+        public int? BatchSizeLimit { get; set; }
+
         [SeqAppSetting(
             IsOptional = true,
             HelpText = "The username to use when authenticating to the SMTP server, if required.")]
@@ -143,32 +280,289 @@ public EmailApp()
             HelpText = "The password to use when authenticating to the SMTP server, if required.")]
         public string Password { get; set; }
 
+        protected override void OnAttached()
+        {
+            if (string.IsNullOrEmpty(Host) && (DeliverUsingDns == null || !(bool)DeliverUsingDns))
+                throw new Exception(
+                    "There are no delivery methods selected - you must specify at least one SMTP Mail Host, or enable Deliver Using DNS");
+
+            if (!(BatchTimeInSeconds > 0)) return;
+            _batchSend = TimeSpan.FromSeconds((int)BatchTimeInSeconds);
+            if (BatchSizeLimit > 0)
+                _batchItems = (int)BatchSizeLimit;
+            else
+                _batchItems = DefaultBatchSizeLimit;
+
+            Log.Debug("Digest mode enabled, batch time {BatchTime}, max items {BatchItems}", _batchSend.TotalSeconds,
+                _batchItems);
+            _timer = new Timer(_batchSend.TotalSeconds * 1000);
+            _timer.Elapsed += SendBatch;
+            _timer.AutoReset = true;
+            _timer.Start();
+        }
         public async Task OnAsync(Event<LogEventData> evt)
         {
             if (ShouldSuppress(evt)) return;
+            if (_batchSend.TotalSeconds > 0)
+            {
+                lock (_sync)
+                {
+                    _waiting.Add(evt);
+                }
+
+                return;
+            }
+
+            if (GetMessage(evt, out var message))
+                await SendEmail(message);
+        }
+
+        async void SendBatch(object sender, ElapsedEventArgs e)
+        {
+            try
+            {
+                Event<LogEventData>[] evts;
+                lock (_sync)
+                {
+                    evts = _waiting.ToArray();
+                    _waiting.Clear();
+                }
+
+                if (!evts.Any())
+                    return;
 
+                var batchLimit = BatchSizeLimit ?? DefaultBatchSizeLimit;
+
+                var batch = evts.Take(batchLimit).ToArray();
+                evts = evts.Skip(batchLimit).ToArray();
+                while (batch.Any())
+                {
+                    if (GetMessage(batch, out var message))
+                        await SendEmail(message);
+
+                    batch = evts.Take(batchLimit).ToArray();
+                    evts = evts.Skip(batchLimit).ToArray();
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Could not send digest email");
+            }
+        }
+
+        async Task SendEmail(MimeMessage message)
+        {
+            var sent = false;
+            var logged = false;
+            var type = DeliveryType.None;
+            var errors = new List<Exception>();
+            var lastServer = string.Empty;
+            if (_options.Value.Host != null && _options.Value.Host.Any())
+            {
+                type = DeliveryType.MailHost;
+                var result = await _mailGateway.SendAsync(_options.Value, message);
+                errors = result.Errors;
+                sent = result.Success;
+                lastServer = result.LastServer;
+
+                if (!result.Success)
+                {
+                    Log.ForContext("From", From).ForContext("To", message.To)
+                        .ForContext("ReplyTo", message.ReplyTo).ForContext("CC", message.Cc)
+                        .ForContext("BCC", message.Bcc)
+                        .ForContext("Priority", message.Priority).ForContext("Subject", message.Subject)
+                        .ForContext("Success", sent).ForContext("Body", message.HtmlBody)
+                        .ForContext(nameof(result.LastServer), result.LastServer)
+                        .ForContext(nameof(result.Type), result.Type).ForContext(nameof(result.Errors), result.Errors)
+                        .Error(result.LastError,
+                            "Error sending mail: {Message}, From: {From}, To: {To}, Subject: {Subject}",
+                            result.LastError?.Message, From, message.To, message.Subject);
+                    logged = true;
+                }
+            }
+
+            if (!sent && _options.Value.DnsDelivery)
+            {
+                type = type == DeliveryType.None ? DeliveryType.Dns : DeliveryType.HostDnsFallback;
+                var result = await _mailGateway.SendDnsAsync(type, _options.Value, message);
+                errors = result.Errors;
+                sent = result.Success;
+                lastServer = result.LastServer;
+                type = result.Type;
+
+                if (!result.Success)
+                {
+                    Log.ForContext("From", From).ForContext("To", message.To)
+                        .ForContext("ReplyTo", message.ReplyTo).ForContext("CC", message.Cc)
+                        .ForContext("BCC", message.Bcc)
+                        .ForContext("Priority", message.Priority).ForContext("Subject", message.Subject)
+                        .ForContext("Success", sent).ForContext("Body", message.HtmlBody)
+                        .ForContext(nameof(result.Results), result.Results, true).ForContext("Errors", errors)
+                        .ForContext(nameof(result.Type), result.Type)
+                        .ForContext(nameof(result.LastServer), result.LastServer)
+                        .Error(result.LastError,
+                            "Error sending mail via DNS: {Message}, From: {From}, To: {To}, Subject: {Subject}",
+                            result.LastError?.Message, From, message.To, message.Subject);
+                    logged = true;
+                }
+            }
+
+            if (sent)
+            {
+                Log.ForContext("From", From).ForContext("To", message.To)
+                    .ForContext("ReplyTo", message.ReplyTo).ForContext("CC", message.Cc).ForContext("BCC", message.Bcc)
+                    .ForContext("Priority", message.Priority).ForContext("Subject", message.Subject)
+                    .ForContext("Success", true).ForContext("Body", message.Body).ForContext("Errors", errors)
+                    .ForContext("Type", type).ForContext("LastServer", lastServer)
+                    .Information("Mail Sent, From: {From}, To: {To}, Subject: {Subject}", From, message.To,
+                        message.Subject);
+            }
+            else if (!logged)
+                Log.ForContext("From", From).ForContext("To", message.To)
+                    .ForContext("ReplyTo", message.ReplyTo).ForContext("CC", message.Cc).ForContext("BCC", message.Bcc)
+                    .ForContext("Priority", message.Priority).ForContext("Subject", message.Subject)
+                    .ForContext("Success", true).ForContext("Body", message.Body).ForContext("Errors", errors)
+                    .ForContext("Type", type).ForContext("LastServer", lastServer)
+                    .Error("Unhandled mail error, From: {From}, To: {To}, Subject: {Subject}", From, message.To,
+                        message.Subject);
+        }
+
+        private bool GetMessage(Event<LogEventData>[] batch, out MimeMessage message)
+        {
+            message = new MimeMessage();
+            var toList = To.Replace(";", ",").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                .Select(t => t.Trim()).ToList().Select(MailboxAddress.Parse).ToList();
+
+            if (toList.Count == 0)
+            {
+                Log.ForContext("To", To).Error(
+                    "Email 'to' address template did not evaluate to one or more recipient addresses - email cannot be sent!");
+                return false;
+            }
+
+            var replyToList = (string.IsNullOrEmpty(ReplyTo)
+                ? new List<string>()
+                : ReplyTo.Replace(";", ",").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(t => t.Trim()).ToList()).Select(MailboxAddress.Parse).ToList();
+            var ccList = (string.IsNullOrEmpty(Cc)
+                ? new List<string>()
+                : Cc.Replace(";", ",").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(t => t.Trim()).ToList()).Select(MailboxAddress.Parse).ToList();
+            var bccList = (string.IsNullOrEmpty(Bcc)
+                ? new List<string>()
+                : Bcc.Replace(";", ",").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(t => t.Trim()).ToList()).Select(MailboxAddress.Parse).ToList();
+
+            var subject = string.IsNullOrWhiteSpace(SubjectTemplate) ? App.Title : SubjectTemplate;
+
+            var body = FormatTemplate(_bodyTemplate.Value, batch, base.Host, App, subject);
+            var textBody = FormatTemplate(_plainTextTemplate.Value, batch, base.Host, App, subject);
+            var priority = _options.Value.Priority;
+
+            message = BuildMimeMessage(toList, subject, body, textBody, replyToList, ccList, bccList, priority);
+
+            return true;
+        }
+
+        private bool GetMessage(Event<LogEventData> evt, out MimeMessage message)
+        {
+            message = new MimeMessage();
             var to = FormatTemplate(_toAddressesTemplate.Value, evt, base.Host)
-                .Split(new[]{','}, StringSplitOptions.RemoveEmptyEntries);
+                .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                .Select(t => t.Trim()).ToList();
 
-            if (to.Length == 0)
+            if (to.Count == 0)
             {
-                Log.Warning("Email 'to' address template did not evaluate to one or more recipient addresses");
-                return;
+                Log.ForContext("To", _toAddressesTemplate.Value).Error(
+                    "Email 'to' address template did not evaluate to one or more recipient addresses - email cannot be sent!");
+                return false;
             }
 
+            var replyTo = string.IsNullOrEmpty(ReplyTo)
+                ? new List<string>()
+                : FormatTemplate(_replyToAddressesTemplate.Value, evt, base.Host)
+                    .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(t => t.Trim()).ToList();
+
+            var cc = string.IsNullOrEmpty(Cc)
+                ? new List<string>()
+                : FormatTemplate(_ccAddressesTemplate.Value, evt, base.Host)
+                    .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(t => t.Trim()).ToList();
+
+            var bcc = string.IsNullOrEmpty(Bcc)
+                ? new List<string>()
+                : FormatTemplate(_bccAddressesTemplate.Value, evt, base.Host)
+                    .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(t => t.Trim()).ToList();
+
+
             var body = FormatTemplate(_bodyTemplate.Value, evt, base.Host);
+            var textBody = FormatTemplate(_plainTextTemplate.Value, evt, base.Host);
             var subject = FormatTemplate(_subjectTemplate.Value, evt, base.Host).Trim().Replace("\r", "")
                 .Replace("\n", "");
             if (subject.Length > MaxSubjectLength)
                 subject = subject.Substring(0, MaxSubjectLength);
 
-            await _mailGateway.SendAsync(
-                _options.Value,
-                new MimeMessage(
-                    new[] {MailboxAddress.Parse(From)},
-                    to.Select(MailboxAddress.Parse),
-                    subject,
-                    new BodyBuilder {HtmlBody = body}.ToMessageBody()));
+            var replyToList = replyTo.Select(MailboxAddress.Parse).ToList();
+            var toList = to.Select(MailboxAddress.Parse).ToList();
+            var ccList = cc.Select(MailboxAddress.Parse).ToList();
+            var bccList = bcc.Select(MailboxAddress.Parse).ToList();
+
+            message = BuildMimeMessage(toList, subject, body, textBody, replyToList, ccList, bccList, GetPriority(evt));
+
+            return true;
+        }
+
+        private MimeMessage BuildMimeMessage(List<MailboxAddress> toList, string subject, string body,
+            string textBody, List<MailboxAddress> replyToList, List<MailboxAddress> ccList,
+            List<MailboxAddress> bccList, EmailPriority priority)
+        {
+            var message = new MimeMessage(
+                new List<InternetAddress> { InternetAddress.Parse(From) },
+                toList, subject,
+                new BodyBuilder
+                    { HtmlBody = body, TextBody = textBody == body ? string.Empty : textBody }.ToMessageBody());
+
+            if (replyToList.Any())
+                message.ReplyTo.AddRange(replyToList);
+
+            if (ccList.Any())
+                message.Cc.AddRange(ccList);
+
+            if (bccList.Any())
+                message.Bcc.AddRange(bccList);
+
+            message.Priority = (MessagePriority)priority;
+
+            return message;
+        }
+
+        private EmailPriority GetPriority(Event<LogEventData> evt)
+        {
+            var priority = EmailPriority.Normal;
+            switch (_options.Value.Priority)
+            {
+                case EmailPriority.UseMapping:
+                    if (!string.IsNullOrEmpty(PriorityProperty) && _options.Value.PriorityMapping.Count > 0 &&
+                        TryGetPropertyValueCI(evt.Data.Properties, PriorityProperty, out var priorityProperty) &&
+                        priorityProperty is string priorityValue &&
+                        _options.Value.PriorityMapping.TryGetValue(priorityValue, out var matchedPriority))
+                        priority = matchedPriority;
+                    else
+                        priority = _options.Value.DefaultPriority;
+                    break;
+                case EmailPriority.Low:
+                case EmailPriority.Normal:
+                case EmailPriority.High:
+                    priority = _options.Value.Priority;
+                    break;
+                default:
+                    priority = EmailPriority.Normal;
+                    break;
+            }
+
+            return priority;
         }
 
         bool ShouldSuppress(Event<LogEventData> evt)
@@ -202,31 +596,61 @@ bool ShouldSuppress(Event<LogEventData> evt)
 
         internal static string FormatTemplate(Template template, Event<LogEventData> evt, Host host)
         {
-            var properties = (IDictionary<string,object>) ToDynamic(evt.Data.Properties ?? new Dictionary<string, object>());
-
-            var payload = (IDictionary<string,object>) ToDynamic(new Dictionary<string, object>
-            {
-                { "$Id",                  evt.Id },
-                { "$UtcTimestamp",        evt.TimestampUtc },
-                { "$LocalTimestamp",      evt.Data.LocalTimestamp },
-                { "$Level",               evt.Data.Level },
-                { "$MessageTemplate",     evt.Data.MessageTemplate },
-                { "$Message",             evt.Data.RenderedMessage },
-                { "$Exception",           evt.Data.Exception },
-                { "$Properties",          properties },
-                { "$EventType",           "$" + evt.EventType.ToString("X8") },
-                { "$Instance",            host.InstanceName },
-                { "$ServerUri",           host.BaseUri },
+            return template((IDictionary<string, object>)ToDynamic(ToPayload(evt, host)));
+        }
+
+        internal static string FormatTemplate(Template template, Event<LogEventData>[] evts, Host host, Apps.App app,
+            string subject)
+        {
+            var payload =
+                (IDictionary<string, object>)ToDynamic(new Dictionary<string, object>
+                {
+                    {
+                        "$Events",
+                        ToDynamic(evts.SelectMany(evt => ToPayload(evt, host))
+                            .ToDictionary(result => result.Key, result => result.Value).ToArray())
+                    },
+                    { "$AppTitle", app.Title },
+                    { "$Subject", subject },
+                    { "$Instance", host.InstanceName },
+                    { "$ServerUri", host.BaseUri },
+                });
+
+            return template(payload);
+        }
+
+        static Dictionary<string, object> ToPayload(Event<LogEventData> evt, Host host)
+        {
+            var properties =
+                (IDictionary<string, object>)ToDynamic(evt.Data.Properties ?? new Dictionary<string, object>());
+
+            var payload = new Dictionary<string, object>
+            {
+                { "$Id", evt.Id },
+                { "$UtcTimestamp", evt.TimestampUtc },
+                { "$LocalTimestamp", evt.Data.LocalTimestamp },
+                { "$Level", evt.Data.Level },
+                { "$MessageTemplate", evt.Data.MessageTemplate },
+                { "$Message", evt.Data.RenderedMessage },
+                { "$Exception", evt.Data.Exception },
+                { "$Properties", properties },
+                { "$EventType", "$" + evt.EventType.ToString("X8") },
+                { "$Instance", host.InstanceName },
+                { "$ServerUri", host.BaseUri },
                 // Note, this will only be valid when events are streamed directly to the app, and not when the app is sending an alert notification.
-                { "$EventUri",            string.Concat(host.BaseUri, "#/events?filter=@Id%20%3D%20'", evt.Id, "'&amp;show=expanded") } 
-            });
+                {
+                    "$EventUri",
+                    string.Concat(host.BaseUri, "#/events?filter=@Id%20%3D%20'", evt.Id, "'&amp;show=expanded")
+                }
+            };
+
 
             foreach (var property in properties)
             {
                 payload[property.Key] = property.Value;
             }
 
-            return template(payload);
+            return payload;
         }
 
         static object ToDynamic(object o)
@@ -234,7 +658,7 @@ static object ToDynamic(object o)
             if (o is IEnumerable<KeyValuePair<string, object>> dictionary)
             {
                 var result = new ExpandoObject();
-                var asDict = (IDictionary<string, object>) result;
+                var asDict = (IDictionary<string, object>)result;
                 foreach (var kvp in dictionary)
                     asDict.Add(kvp.Key, ToDynamic(kvp.Value));
                 return result;
@@ -247,5 +671,24 @@ static object ToDynamic(object o)
 
             return o;
         }
+
+        static bool TryGetPropertyValueCI(IReadOnlyDictionary<string, object> properties, string propertyName,
+            out object propertyValue)
+        {
+            var pair = properties.FirstOrDefault(p => p.Key.Equals(propertyName, StringComparison.OrdinalIgnoreCase));
+            if (pair.Key == null)
+            {
+                propertyValue = null;
+                return false;
+            }
+
+            propertyValue = pair.Value;
+            return true;
+        }
+
+        public SmtpOptions GetOptions()
+        {
+            return _options.Value;
+        }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Seq.App.EmailPlus/EmailPriority.cs b/src/Seq.App.EmailPlus/EmailPriority.cs
new file mode 100644
index 0000000..f0f44ad
--- /dev/null
+++ b/src/Seq.App.EmailPlus/EmailPriority.cs
@@ -0,0 +1,12 @@
+using MimeKit;
+
+namespace Seq.App.EmailPlus
+{
+    public enum EmailPriority
+    {
+        Low = MessagePriority.NonUrgent,
+        Normal = MessagePriority.Normal,
+        High = MessagePriority.Urgent,
+        UseMapping = -1,
+    }
+}
\ No newline at end of file
diff --git a/src/Seq.App.EmailPlus/HandlebarsHelpers.cs b/src/Seq.App.EmailPlus/HandlebarsHelpers.cs
index fae0363..8a8cb3d 100644
--- a/src/Seq.App.EmailPlus/HandlebarsHelpers.cs
+++ b/src/Seq.App.EmailPlus/HandlebarsHelpers.cs
@@ -2,7 +2,6 @@
 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 
 namespace Seq.App.EmailPlus
diff --git a/src/Seq.App.EmailPlus/IMailGateway.cs b/src/Seq.App.EmailPlus/IMailGateway.cs
index ed599a2..6baa09a 100644
--- a/src/Seq.App.EmailPlus/IMailGateway.cs
+++ b/src/Seq.App.EmailPlus/IMailGateway.cs
@@ -5,6 +5,7 @@ namespace Seq.App.EmailPlus
 {
     interface IMailGateway
     {
-        Task SendAsync(SmtpOptions options, MimeMessage message);
+        Task<MailResult> SendAsync(SmtpOptions options, MimeMessage message);
+        Task<DnsMailResult> SendDnsAsync(DeliveryType deliveryType, SmtpOptions options, MimeMessage message);
     }
 }
\ No newline at end of file
diff --git a/src/Seq.App.EmailPlus/MailResult.cs b/src/Seq.App.EmailPlus/MailResult.cs
index 6aa6fa1..0bbf3af 100644
--- a/src/Seq.App.EmailPlus/MailResult.cs
+++ b/src/Seq.App.EmailPlus/MailResult.cs
@@ -1,10 +1,14 @@
 using System;
+using System.Collections.Generic;
 
 namespace Seq.App.EmailPlus
 {
     public class MailResult
     {
-        public bool Success;
-        public Exception Errors;
+        public bool Success { get; set; }
+        public DeliveryType Type { get; set; }
+        public string LastServer { get; set; }
+        public Exception LastError { get; set; }
+        public List<Exception> Errors { get; set; } = new List<Exception>();
     }
 }
\ No newline at end of file
diff --git a/src/Seq.App.EmailPlus/Resources.Designer.cs b/src/Seq.App.EmailPlus/Resources.Designer.cs
index 4068fe5..ed5db4c 100644
--- a/src/Seq.App.EmailPlus/Resources.Designer.cs
+++ b/src/Seq.App.EmailPlus/Resources.Designer.cs
@@ -19,10 +19,10 @@ namespace Seq.App.EmailPlus {
     // class via a tool like ResGen or Visual Studio.
     // To add or remove a member, edit your .ResX file then rerun ResGen
     // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    internal class Resources {
+    public class Resources {
         
         private static global::System.Resources.ResourceManager resourceMan;
         
@@ -36,7 +36,7 @@ internal Resources() {
         ///   Returns the cached ResourceManager instance used by this class.
         /// </summary>
         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Resources.ResourceManager ResourceManager {
+        public static global::System.Resources.ResourceManager ResourceManager {
             get {
                 if (object.ReferenceEquals(resourceMan, null)) {
                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Seq.App.EmailPlus.Resources", typeof(Resources).Assembly);
@@ -51,7 +51,7 @@ internal Resources() {
         ///   resource lookups using this strongly typed resource class.
         /// </summary>
         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Globalization.CultureInfo Culture {
+        public static global::System.Globalization.CultureInfo Culture {
             get {
                 return resourceCulture;
             }
@@ -72,10 +72,34 @@ internal Resources() {
         ///    &lt;tr&gt;
         ///         [rest of string was truncated]&quot;;.
         /// </summary>
-        internal static string DefaultBodyTemplate {
+        public static string DefaultBodyTemplate {
             get {
                 return ResourceManager.GetString("DefaultBodyTemplate", resourceCulture);
             }
         }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to &lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD XHTML 1.0 Transitional//EN&quot; &quot;http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd&quot;&gt;
+        ///&lt;html xmlns=&quot;http://www.w3.org/1999/xhtml&quot;&gt;
+        ///&lt;head&gt;
+        ///  &lt;title&gt;{{$Subject}}&lt;/title&gt;
+        ///  &lt;meta http-equiv=&quot;Content-Type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;
+        ///  &lt;style&gt;
+        ///    .email-body {
+        ///      margin: 10px;
+        ///      font-family: &quot;Helvetica Neue&quot;,Helvetica,Arial,sans-serif;
+        ///      font-size: 14px;
+        ///      line-height: 20px;
+        ///      color: #333;
+        ///      background-color: #fff;
+        ///    }
+        ///
+        ///    .s [rest of string was truncated]&quot;;.
+        /// </summary>
+        public static string DigestBodyTemplate {
+            get {
+                return ResourceManager.GetString("DigestBodyTemplate", resourceCulture);
+            }
+        }
     }
 }
diff --git a/src/Seq.App.EmailPlus/Resources.resx b/src/Seq.App.EmailPlus/Resources.resx
index 3f5577e..958679f 100644
--- a/src/Seq.App.EmailPlus/Resources.resx
+++ b/src/Seq.App.EmailPlus/Resources.resx
@@ -121,4 +121,7 @@
   <data name="DefaultBodyTemplate" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>Resources\DefaultBodyTemplate.html;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
   </data>
+  <data name="DigestBodyTemplate" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DigestBodyTemplate.html;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Seq.App.EmailPlus/Resources/DigestBodyTemplate.html b/src/Seq.App.EmailPlus/Resources/DigestBodyTemplate.html
new file mode 100644
index 0000000..70cfe5b
--- /dev/null
+++ b/src/Seq.App.EmailPlus/Resources/DigestBodyTemplate.html
@@ -0,0 +1,162 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+  <title>{{$Subject}}</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+  <style>
+    .email-body {
+      margin: 10px;
+      font-family: "Helvetica Neue",Helvetica,Arial,sans-serif;
+      font-size: 14px;
+      line-height: 20px;
+      color: #333;
+      background-color: #fff;
+    }
+
+    .seq-event-tools {
+      float: left;
+      margin-right: 5px;
+    }
+
+    .seq-event-data {
+      margin-top: 2px;
+      margin-left: 190px;
+      overflow: visible;
+      white-space: normal;
+    }
+
+    .seq-event-properties {
+      margin-top: 5px;
+    }
+
+    .seq-property {
+      width: 100%;
+    }
+
+    .seq-property-name {
+      float: left;
+      width: 200px;
+      overflow: hidden;
+      font-family: monospace;
+      font-size: 13px;
+      font-weight: bold;
+      text-overflow: ellipsis;
+    }
+
+    .seq-property-value {
+      margin-left: 245px;
+      font-family: monospace;
+      font-size: 13px;
+      word-wrap: break-word;
+      white-space: pre-wrap;
+    }
+
+    .seq-event-actions {
+      margin-top: 5px;
+    }
+
+      .seq-event-actions a.action {
+        padding-right: 10px;
+        font-size: 12px;
+      }
+
+    a {
+      color: #007acc;
+      text-decoration: none;
+    }
+
+    .seq-event-timestamp {
+      margin-right: 5px;
+      color: white;
+    }
+
+      .seq-event-timestamp .datetime {
+        display: inline-block;
+        width: 172px;
+        padding: 2px 4px;
+        font-size: 11.844px;
+        font-weight: bold;
+        line-height: 14px;
+        color: #fff;
+        text-shadow: none;
+        white-space: nowrap;
+        vertical-align: baseline;
+        background-color: #aaa;
+        -webkit-border-radius: 3px;
+        -moz-border-radius: 3px;
+        border-radius: 2px;
+        margin-top: 2px;
+      }
+
+    .seq-event-detail {
+      width: 100%;
+      padding: 0 2px 2px 2px;
+      margin: 2px -3px 0 -3px;
+      overflow: visible;
+      white-space: nowrap;
+      border-style: solid;
+      border-width: 1px;
+      border-radius: 2px;
+      background-color: #eff9ff;
+      border-color: #54afcc;
+    }
+
+    .seq-event-exception {
+      padding: 2px;
+      margin-top: 5px;
+      overflow: auto;
+      font-family: monospace;
+      font-size: 9pt;
+      color: white;
+      white-space: pre;
+      background-color: #e03836;
+    }
+
+    .email-footer {
+      margin-top: 20px;
+      font-size: 9pt;
+      font-style: italic;
+      color: #ddd;
+    }
+
+      .email-footer a {
+        color: #ddd;
+        font-weight: bold;
+      }
+  </style>
+</head>
+<body>
+  <div class="email-body" style="margin-top:10px;margin-bottom:10px;margin-right:10px;margin-left:10px;font-family:'Helvetica Neue',Helvetica,Arial,sans-serif;font-size:14px;line-height:20px;color:#333;background-color:#fff;">
+    {{#each $Events}}
+    <div class="seq-event-detail" style="width:100%;padding-top:0;padding-bottom:2px;padding-right:2px;padding-left:2px;margin-top:2px;margin-bottom:0;margin-right:-3px;margin-left:-3px;overflow:visible;white-space:nowrap;border-style:solid;border-width:1px;border-radius:2px;background-color:#eff9ff;border-color:#54afcc;">
+      <div class="seq-event-tools" style="float:left;margin-right:5px;">
+        <span class="seq-event-timestamp" title="{{$UtcTimestamp}}" style="margin-right:5px;color:white;"><span class="datetime" style="display:inline-block;width:172px;padding-top:2px;padding-bottom:2px;padding-right:4px;padding-left:4px;font-size:11.844px;font-weight:bold;line-height:14px;color:#fff;text-shadow:none;white-space:nowrap;vertical-align:baseline;background-color:#aaa;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:2px;margin-top:2px;">{{$LocalTimestamp}}</span></span>
+      </div>
+      <div class="seq-event-data" style="margin-top:2px;margin-left:190px;overflow:visible;white-space:normal;">
+        <div>
+          <span class="seq-message-template">[<strong>{{$Level}}</strong>] {{$Message}}</span>
+        </div>
+        <div class="seq-event-actions" style="margin-top:5px;">
+          <a href="{{{../$ServerUri}}}#/events?filter=@Id%3D'{{$Id}}'&show=expanded" class="action" style="color:#007acc;text-decoration:none;padding-right:10px;font-size:12px;">View in Seq</a>
+        </div>
+        <div class="seq-event-properties" style="margin-top:5px;">
+          {{#each $Properties}}
+          <div class="seq-event-property">
+            <div class="seq-property-name" title="{{@key}}" style="float:left;width:200px;overflow:hidden;font-family:monospace;font-size:13px;font-weight:bold;text-overflow:ellipsis;">{{@key}}</div>
+            <div class="seq-property-value" style="margin-left:245px;font-family:monospace;font-size:13px;word-wrap:break-word;white-space:pre-wrap;">{{pretty this}}</div>
+          </div>
+          {{/each}}
+          {{#if $Exception}}
+          <pre class="seq-event-exception" style="padding-top:2px;padding-bottom:2px;padding-right:2px;padding-left:2px;margin-top:5px;overflow:auto;font-family:monospace;font-size:9pt;color:white;white-space:pre;background-color:#e03836;">{{$Exception}}</pre>
+          {{/if}}
+        </div>
+      </div>
+    </div>
+    {{/each}}
+    <div class="email-footer" style="margin-top:20px;font-size:9pt;font-style:italic;color:#ddd;">
+      Sent from <a href="https://getseq.net" style="text-decoration:none;color:#ddd;font-weight:bold;">Seq</a> &mdash; structured log server for .NET &mdash; installed
+      at <a href='{{{$ServerUri}}}' style="text-decoration:none;color:#ddd;font-weight:bold;">{{$ServerUri}}</a>.
+    </div>
+  </div>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/Seq.App.EmailPlus/Seq.App.EmailPlus.csproj b/src/Seq.App.EmailPlus/Seq.App.EmailPlus.csproj
index aaab5e9..9e9276c 100644
--- a/src/Seq.App.EmailPlus/Seq.App.EmailPlus.csproj
+++ b/src/Seq.App.EmailPlus/Seq.App.EmailPlus.csproj
@@ -17,6 +17,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="DnsClient" Version="1.5.0" />
     <PackageReference Include="MailKit" Version="2.14.0" />
     <PackageReference Include="Seq.Apps" Version="5.1.0" />
     <PackageReference Include="Serilog" Version="2.10.0" />
@@ -30,4 +31,19 @@
     <None Include="./obj/publish/**/*" Exclude="./obj/publish/Seq.App.EmailPlus.dll;./obj/publish/Seq.Apps.dll;./obj/publish/Serilog.dll" Pack="true" PackagePath="lib/$(TargetFramework)" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Update="Resources.Designer.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Update="Resources.resx">
+      <Generator>PublicResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+
 </Project>
diff --git a/src/Seq.App.EmailPlus/SmtpOptions.cs b/src/Seq.App.EmailPlus/SmtpOptions.cs
index ec2d0c5..c262174 100644
--- a/src/Seq.App.EmailPlus/SmtpOptions.cs
+++ b/src/Seq.App.EmailPlus/SmtpOptions.cs
@@ -1,25 +1,88 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using MailKit.Security;
 
 namespace Seq.App.EmailPlus
 {
-    class SmtpOptions
+    public class SmtpOptions
     {
-        public string Host { get; }
-        public int Port { get; }
-        public string Username { get; }
-        public string Password { get; }
-        public SecureSocketOptions SocketOptions { get; }
-
+        public List<string> Host { get; set; }
+        public bool DnsDelivery { get; set; }
+        public int Port { get; set; }
+        public string Username { get; set; }
+        public string Password { get; set; }
         public bool RequiresAuthentication => !string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(Password);
+        public EmailPriority Priority { get; set; }
+        public Dictionary<string, EmailPriority> PriorityMapping { get; set; }
+        public EmailPriority DefaultPriority { get; set; }
+        public SecureSocketOptions SocketOptions { get; set; }
 
-        public SmtpOptions(string host, int port, SecureSocketOptions socketOptions, string username = null, string password = null)
+        public SmtpOptions(string host, bool dnsDelivery, int port, string priority, string defaultPriority, SecureSocketOptions socketOptions, string username = null, string password = null)
         {
-            Host = host ?? throw new ArgumentNullException(nameof(host));
+            Host = GetServerList(host).ToList();
+            DnsDelivery = dnsDelivery;
+			Priority = ParsePriority(priority, out var priorityMapping);
+			PriorityMapping = priorityMapping;
+			DefaultPriority = ParsePriority(defaultPriority);
             Port = port;
             Username = username;
             Password = password;
             SocketOptions = socketOptions;
         }
+      
+        static IEnumerable<string> GetServerList(string hostName)
+        {
+            if (!string.IsNullOrEmpty(hostName))
+                return hostName.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(t => t.Trim()).ToList();
+            return new List<string>();
+        }
+
+        public static SecureSocketOptions GetSocketOptions(int port, bool? enableSsl, bool? useTlsWhenAvailable)
+        {
+            if (enableSsl == null) return SecureSocketOptions.Auto;
+            switch (enableSsl)
+            {
+                case true when port == 465: //Implicit TLS
+                    return SecureSocketOptions.SslOnConnect;
+                case true:
+                    return SecureSocketOptions.StartTls;
+                case false when port == 465: //Implicit TLS
+                    return SecureSocketOptions.SslOnConnect;
+                case false when useTlsWhenAvailable != null && !(bool) useTlsWhenAvailable:
+                    return SecureSocketOptions.None;
+                case false when useTlsWhenAvailable != null && (bool) useTlsWhenAvailable:
+                    return SecureSocketOptions.StartTlsWhenAvailable;
+            }
+
+            return SecureSocketOptions.Auto;
+        }
+
+        static EmailPriority ParsePriority(string priority, out Dictionary<string,EmailPriority> priorityList)
+        {
+            priorityList = new Dictionary<string, EmailPriority>(StringComparer.OrdinalIgnoreCase);
+            if (string.IsNullOrEmpty(priority)) return EmailPriority.Normal;
+            if (!priority.Contains('='))
+                return Enum.TryParse(priority, out EmailPriority priorityValue) ? priorityValue : EmailPriority.Normal;
+            foreach (var kv in priority.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries)
+                .Select(t => t.Trim()).ToList().Select(p => p.Split(new[] {'='}, StringSplitOptions.RemoveEmptyEntries).Select(t => t.Trim())
+                    .ToArray()))
+            {
+                if (kv.Length != 2 || !Enum.TryParse(kv[1], true, out EmailPriority value) ||
+                    value == EmailPriority.UseMapping) return EmailPriority.Normal;
+
+                priorityList.Add(kv[0], value);
+            }
+
+            return priorityList.Count > 0 ? EmailPriority.UseMapping : EmailPriority.Normal;
+
+        }
+
+        static EmailPriority ParsePriority(string priority)
+        {
+            if (string.IsNullOrEmpty(priority)) return EmailPriority.Normal;
+            return Enum.TryParse(priority, out EmailPriority priorityValue) ? priorityValue : EmailPriority.Normal;
+        }
     }
 }
diff --git a/test/Seq.App.EmailPlus.Tests/EmailAppTests.cs b/test/Seq.App.EmailPlus.Tests/EmailAppTests.cs
index 6513ae9..b1b8577 100644
--- a/test/Seq.App.EmailPlus.Tests/EmailAppTests.cs
+++ b/test/Seq.App.EmailPlus.Tests/EmailAppTests.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using MailKit.Security;
+using MimeKit;
 using Seq.App.EmailPlus.Tests.Support;
 using Seq.Apps;
 using Seq.Apps.LogEvents;
@@ -131,6 +133,57 @@ public async Task ToAddressesAreTemplated()
             Assert.Equal("test@example.com", to.ToString());
         }
 
+        [Fact]
+        public async Task OptionalAddressesAreTemplated()
+        {
+            var mail = new CollectingMailGateway();
+            var app = new EmailApp(mail, new SystemClock())
+            {
+                From = "from@example.com",
+                ReplyTo = "{{Name}}@example.com",
+                To = "{{Name}}@example.com",
+                Cc = "{{Name}}@example.com",
+                Bcc = "{{Name}}@example.com",
+                Host = "example.com"
+            };
+
+            app.Attach(new TestAppHost());
+
+            var data = Some.LogEvent(includedProperties: new Dictionary<string, object> { { "Name", "test" } });
+            await app.OnAsync(data);
+
+            var sent = Assert.Single(mail.Sent);
+            Assert.Equal("test@example.com", sent.Message.ReplyTo.ToString());
+            Assert.Equal("test@example.com", sent.Message.Cc.ToString());
+            Assert.Equal("test@example.com", sent.Message.Bcc.ToString());
+        }
+
+        [Fact]
+        public void FallbackHostsCalculated()
+        {
+            var mail = new CollectingMailGateway();
+            var reactor = new EmailApp(mail, new SystemClock())
+            {
+                From = "from@example.com",
+                To = "{{Name}}@example.com",
+                Host = "example.com,example2.com"
+            };
+
+            reactor.Attach(new TestAppHost());
+            Assert.True(reactor.GetOptions().Host.Count() == 2);
+        }
+
+        [Fact]
+        public void ParseDomainTest()
+        {
+            var mail = new DirectMailGateway();
+            var domains = DirectMailGateway.GetDomains(new MimeMessage(
+                new List<InternetAddress> {InternetAddress.Parse("test@example.com")},
+                new List<InternetAddress> {InternetAddress.Parse("test2@example.com"), InternetAddress.Parse("test3@example.com"), InternetAddress.Parse("test@example2.com")}, "Test",
+                (new BodyBuilder {HtmlBody = "test"}).ToMessageBody()));
+            Assert.True(domains.Count() == 2);
+        }
+
         [Fact]
         public async Task EventsAreSuppressedWithinWindow()
         {
@@ -203,12 +256,19 @@ public async Task ToAddressesCanBeCommaSeparated()
         }
 
         [Theory]
-        [InlineData(25, SecureSocketOptions.StartTls)]
-        [InlineData(587, SecureSocketOptions.StartTls)]
-        [InlineData(465, SecureSocketOptions.SslOnConnect)]
-        public void CorrectSecureSocketOptionsAreChosenForPort(int port, SecureSocketOptions expected)
+        [InlineData(25, null, null, SecureSocketOptions.Auto)]
+        [InlineData(25, true, false, SecureSocketOptions.StartTls)]
+        [InlineData(25, false, false, SecureSocketOptions.None)]
+        [InlineData(25, false, true, SecureSocketOptions.StartTlsWhenAvailable)]
+        [InlineData(587, true, false, SecureSocketOptions.StartTls)]
+        [InlineData(587, false, false, SecureSocketOptions.None)]
+        [InlineData(587, false, true, SecureSocketOptions.StartTlsWhenAvailable)]
+        [InlineData(465, true, false, SecureSocketOptions.SslOnConnect)]
+        [InlineData(465, false, false, SecureSocketOptions.SslOnConnect)]
+        [InlineData(465, false, true, SecureSocketOptions.SslOnConnect)]
+        public void CorrectSecureSocketOptionsAreChosenForPort(int port, bool? enableSsl, bool? optionalTls, SecureSocketOptions expected)
         {
-            Assert.Equal(expected, EmailApp.RequireSslForPort(port));
+            Assert.Equal(expected, SmtpOptions.GetSocketOptions(port, enableSsl, optionalTls));
         }
     }
 }
diff --git a/test/Seq.App.EmailPlus.Tests/Support/CollectingMailGateway.cs b/test/Seq.App.EmailPlus.Tests/Support/CollectingMailGateway.cs
index d5e2ac7..088e021 100644
--- a/test/Seq.App.EmailPlus.Tests/Support/CollectingMailGateway.cs
+++ b/test/Seq.App.EmailPlus.Tests/Support/CollectingMailGateway.cs
@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using MailKit.Net.Smtp;
 using MimeKit;
 
 namespace Seq.App.EmailPlus.Tests.Support
@@ -9,10 +8,18 @@ class CollectingMailGateway : IMailGateway
     {
         public List<SentMessage> Sent { get; } = new List<SentMessage>();
 
-        public Task SendAsync(SmtpOptions options, MimeMessage message)
+        public async Task<MailResult> SendAsync(SmtpOptions options, MimeMessage message)
         {
-            Sent.Add(new SentMessage(message));
-            return Task.CompletedTask;
+            await Task.Run(() => Sent.Add(new SentMessage(message)));
+            
+            return new MailResult {Success = true};
+        }
+
+        public async Task<DnsMailResult> SendDnsAsync(DeliveryType deliveryType, SmtpOptions options, MimeMessage message)
+        {
+            await Task.Run(() => Sent.Add(new SentMessage(message)));
+            
+            return new DnsMailResult {Success = true};
         }
     }
 }
diff --git a/test/Seq.App.EmailPlus.Tests/Support/SentMessage.cs b/test/Seq.App.EmailPlus.Tests/Support/SentMessage.cs
index ebd7712..4e1a6ee 100644
--- a/test/Seq.App.EmailPlus.Tests/Support/SentMessage.cs
+++ b/test/Seq.App.EmailPlus.Tests/Support/SentMessage.cs
@@ -1,6 +1,4 @@
-
-using MailKit.Net.Smtp;
-using MimeKit;
+using MimeKit;
 
 namespace Seq.App.EmailPlus.Tests.Support
 {