/// <summary>
        /// Adds a sink that lets you push log messages to RabbitMq
        /// </summary>
        public static LoggerConfiguration RabbitMQ(
            this LoggerSinkConfiguration loggerConfiguration,
            RabbitMQConfiguration rabbitMqConfiguration,
            ITextFormatter formatter,
            IFormatProvider formatProvider = null)
        {
            if (loggerConfiguration == null) throw new ArgumentNullException("loggerConfiguration");
            if (rabbitMqConfiguration == null) throw new ArgumentNullException("rabbitMqConfiguration");

            // calls overloaded extension method
            return loggerConfiguration.RabbitMQ(
                rabbitMqConfiguration.Hostname,
                rabbitMqConfiguration.Username,
                rabbitMqConfiguration.Password,
                rabbitMqConfiguration.Exchange,
                rabbitMqConfiguration.ExchangeType,
                rabbitMqConfiguration.Queue,
                rabbitMqConfiguration.DeliveryMode,
                rabbitMqConfiguration.RouteKey,
                rabbitMqConfiguration.Port,
                rabbitMqConfiguration.VHost,
                rabbitMqConfiguration.Heartbeat,
                rabbitMqConfiguration.Protocol,
                formatter,
                formatProvider);
        }

        public string CompositeIdMap(IList<Column> columns, ITextFormatter formatter)
        {
            var builder = new StringBuilder();

            switch (_language)
            {
                case Language.CSharp:
                    builder.AppendLine("ComposedId(compId =>");
                    builder.AppendLine("\t\t\t\t{");
                    foreach (var column in columns)
                    {
                        builder.AppendLine("\t\t\t\t\tcompId.Property(x => x." + formatter.FormatText(column.Name) + ", m => m.Column(\"" + column.Name + "\"));");
                    }
                    builder.Append("\t\t\t\t});");
                    break;
                case Language.VB:
                    builder.AppendLine("ComposedId(Sub(compId)");
                    foreach (var column in columns)
                    {
                        builder.AppendLine("\t\t\t\t\tcompId.Property(Function(x) x." + formatter.FormatText(column.Name) + ", Sub(m) m.Column(\"" + column.Name + "\"))");
                    }
                    builder.AppendLine("\t\t\t\tEnd Sub)");
                    break;
            }

            return builder.ToString();
        }

 public OutputSink(Func<IOutput> outputProvider, ITextFormatter textFormatter, Func<IOutputLogFilter> outputLogFilterProvider = null)
 {
     if (textFormatter == null) throw new ArgumentNullException("textFormatter");
     _textFormatter = textFormatter;
     _outputProvider = outputProvider;
     _outputLogFilterProvider = outputLogFilterProvider;
 }

 public override string Format(IPostParsingContext context, ITextFormatter<IPostParsingContext> formatter)
 {
     if(this.Name.ToLower() == "q" || this.Name.ToLower() == "quote") {
         return "";
     } else if(this.Name.ToLower() == "code") {
         return "[code]" + this.InnerBBCode + "[/code]";
     } else {
         string name = this.Name;
         if(name.ToLower() == "uploadimage") name = "uploadLink";
         var sb = new StringBuilder();
         sb.Append("[");
         sb.Append(name);
         if(this.Default != null && this.Default != "") {
             sb.Append("='");
             sb.Append(this.Default.Replace("'", "''"));
             sb.Append("'");
         } else {
             foreach(var attribute in this.Attributes) {
                 sb.Append(" ");
                 sb.Append(attribute.Key);
                 sb.Append("='");
                 sb.Append(attribute.Value.Replace("'", "''"));
                 sb.Append("'");
             }
         }
         sb.Append("]");
         if(this.RequireClosingTag) {
             sb.Append(this.GetInnerHTML(context, formatter));
             sb.Append("[/");
             sb.Append(name);
             sb.Append("]");
         }
         return sb.ToString();
     }
 }

 public FileSink(string path, ITextFormatter textFormatter)
 {
     if (path == null) throw new ArgumentNullException("path");
     if (textFormatter == null) throw new ArgumentNullException("textFormatter");
     _textFormatter = textFormatter;
     _output = new StreamWriter(System.IO.File.Open(path, FileMode.Append, FileAccess.Write, FileShare.Read));
 }

        public XUnitTestOutputSink(ITestOutputHelper testOutputHelper, ITextFormatter textFormatter)
        {
            if (testOutputHelper == null) throw new ArgumentNullException("testOutputHelper");
            if (textFormatter == null) throw new ArgumentNullException("textFormatter");

            _output = testOutputHelper;
            _textFormatter = textFormatter;
        }

 public override string Format(IPostParsingContext context, ITextFormatter<IPostParsingContext> formatter)
 {
     string inner = this.GetInnerHTML(context, formatter).TrimHtml();
     if(inner == "") return "";
     string marker = this.Default;
     if(marker == null) marker = "Quote:";
     return "<blockquote><div class=\"quotetitle\">" + marker + "</div><div class=\"quotecontent\">" + inner + "</div></blockquote>";
 }

 public static LoggerConfiguration DummyRollingFile(
     this LoggerSinkConfiguration loggerSinkConfiguration,
     ITextFormatter formatter,
     string pathFormat,
     LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum)
 {
     return loggerSinkConfiguration.Sink(new DummyRollingFileSink(), restrictedToMinimumLevel);
 }

 public override string Format(IPostParsingContext context, ITextFormatter<IPostParsingContext> formatter)
 {
     var upload = dataobjects.Upload.LoadById(int.Parse(this.DefaultOrValue));
     var name = this.Safe(upload.filename);
     if(this.Default != null) {
         name = this.GetInnerHTML(context, formatter);
     }
     return "<a href=\"/Upload/Info/" + upload.id.ToString() + "/\">" + name + "</a>";
 }

 public SizeLimitedFileSink(ITextFormatter formatter, TemplatedPathRoller roller, long fileSizeLimitBytes,
     RollingLogFile rollingLogFile, Encoding encoding = null)
 {
     this.formatter = formatter;
     this.roller = roller;
     this.fileSizeLimitBytes = fileSizeLimitBytes;
     this.EnableLevelLogging = roller.PathIncludesLevel;
     this.output = OpenFileForWriting(roller.LogFileDirectory, rollingLogFile, encoding ?? Encoding.UTF8);
 }

 public override string Format(IPostParsingContext context, ITextFormatter<IPostParsingContext> formatter)
 {
     var url = this.url;
     var name = this.Safe(url.title);
     if(this.Default != null) {
         name = this.GetInnerHTML(context, formatter);
     }
     return string.Format("<a href=\"{0}\">{1}</a>", url.canonical, url.title);
 }

 public override string Format(IPostParsingContext context, ITextFormatter<IPostParsingContext> formatter)
 {
     string rawUrl = this.DefaultOrValue;
     string title = null;
     if(rawUrl.ToLower() != this.InnerText.ToLower()) {
         title = this.GetInnerHTML(context, formatter);
     }
     return UrlProcessor.ProcessLink(rawUrl, title, false);
 }

 public override string Format(IPostParsingContext context, ITextFormatter<IPostParsingContext> formatter)
 {
     var urlInfo = UrlProcessor.Process(this.InnerText);
     if (urlInfo.isLocal && urlInfo.relativeUrl.StartsWith("/user/upload/")) {
         return "<f:img><f:src>" + urlInfo.relativeUrl + "</f:src><f:alt>" + urlInfo.relativeUrl + "</f:alt></f:img>";
     } else {
         return "<a href=\"" + urlInfo.relativeUrl + "\">" + urlInfo.relativeUrl + "</a>";
     }
 }

 public RabbitMQSink(RabbitMQConfiguration configuration,
     ITextFormatter formatter,
     IFormatProvider formatProvider)
     : base(configuration.BatchPostingLimit, configuration.Period)
 {
     _formatter = formatter ?? new RawFormatter();
     _formatProvider = formatProvider;
     _client = new RabbitMQClient(configuration);
 }

 /// <summary>
 /// Construct a sink that saves log events to the specified EventHubClient.
 /// </summary>
 /// <param name="eventHubClient">The EventHubClient to use in this sink.</param>
 /// <param name="partitionKey">PartitionKey to group events by within the Event Hub.</param>
 /// <param name="formatter">Provides formatting for outputting log data</param>
 public AzureEventHubSink(
     EventHubClient eventHubClient,
     string partitionKey,
     ITextFormatter formatter)
 {
     _eventHubClient = eventHubClient;
     _partitionKey = partitionKey;
     _formatter = formatter;
 }

        /// <summary>
        /// Construct a sink that uses datadog with the specified details.
        /// </summary>
        /// <param name="datadogConfiguration">Connection information used to construct the Datadog client.</param>
        /// <param name="batchSizeLimit">The maximum number of events to post in a single batch.</param>
        /// <param name="period">The time to wait between checking for event batches.</param>
        /// <param name="textFormatter">Supplies culture-specific formatting information, or null.</param>
        public DatadogSink(DatadogConfiguration datadogConfiguration, int batchSizeLimit, TimeSpan period, ITextFormatter textFormatter)
            : base(batchSizeLimit, period)
        {
            if (datadogConfiguration == null) throw new ArgumentNullException("datadogConfiguration");

            _datadogConfiguration = datadogConfiguration;
            _textFormatter = textFormatter;
            _statsdUdp = new StatsdUDP(datadogConfiguration.StatsdServer, datadogConfiguration.StatsdPort);
            _statsd = new Statsd(_statsdUdp);
        }

        /// <summary>
        /// Construct a sink emailing with the specified details.
        /// </summary>
        /// <param name="connectionInfo">Connection information used to construct the SMTP client and mail messages.</param>
        /// <param name="batchSizeLimit">The maximum number of events to post in a single batch.</param>
        /// <param name="period">The time to wait between checking for event batches.</param>
        /// <param name="textFormatter">Supplies culture-specific formatting information, or null.</param>
        public EmailSink(EmailConnectionInfo connectionInfo, int batchSizeLimit, TimeSpan period, ITextFormatter textFormatter)
            : base(batchSizeLimit, period)
        {
            if (connectionInfo == null) throw new ArgumentNullException(nameof(connectionInfo));

            _connectionInfo = connectionInfo;
            _textFormatter = textFormatter;
            _smtpClient = CreateSmtpClient();
            _smtpClient.SendCompleted += SendCompletedCallback;
        }

        /// <summary>
        /// Construct a sink posting to the Windows event log, creating the specified <paramref name="source"/> if it does not exist.
        /// </summary>
        /// <param name="source">The source name by which the application is registered on the local computer. </param>
        /// <param name="logName">The name of the log the source's entries are written to. Possible values include Application, System, or a custom event log.</param>
        /// <param name="textFormatter">Supplies culture-specific formatting information, or null.</param>
        /// <param name="machineName">The name of the machine hosting the event log written to.</param>
        public EventLogSink(string source, string logName, ITextFormatter textFormatter, string machineName)
        {
            if (source == null) throw new ArgumentNullException("source");

            _textFormatter = textFormatter;
            _source = source;

            var sourceData = new EventSourceCreationData(source, logName) { MachineName = machineName };

            if (!System.Diagnostics.EventLog.SourceExists(source, machineName)) System.Diagnostics.EventLog.CreateEventSource(sourceData);
        }

        public RabbitMQSink(
            RabbitMQConfiguration configuration,
            ITextFormatter formatter,
            IFormatProvider formatProvider
       )
        {

            // prepare client
            _client = new RabbitMQClient(configuration);
            _formatProvider = formatProvider;
            _formatter = formatter ?? new RawFormatter();
        }

        /// <summary>
        /// Construct a sink emailing with the specified details.
        /// </summary>
        /// <param name="fromEmail">The email address emails will be sent from</param>
        /// <param name="toEmail">The email address emails will be sent to</param>
        /// <param name="mailServer">The SMTP email server to use</param>
        /// <param name="networkCredential">The network credentials to use to authenticate with mailServer</param>
        /// <param name="batchSizeLimit">The maximum number of events to post in a single batch.</param>
        /// <param name="period">The time to wait between checking for event batches.</param>
        /// <param name="textFormatter">Supplies culture-specific formatting information, or null.</param>
        public EmailSink(string fromEmail, string toEmail, string mailServer, ICredentialsByHost networkCredential, int batchSizeLimit, TimeSpan period, ITextFormatter textFormatter) 
            : base(batchSizeLimit, period)
        {
            if (fromEmail == null) throw new ArgumentNullException("fromEmail");
            if (toEmail == null) throw new ArgumentNullException("toEmail");
            if (mailServer == null) throw new ArgumentNullException("mailServer");

            _fromEmail = fromEmail;
            _toEmail = toEmail;
            _textFormatter = textFormatter;

            _smtpClient = new SmtpClient(mailServer) {Credentials = networkCredential};
            _smtpClient.SendCompleted += SendCompletedCallback;
        }