public void Apply(int waitingLogEntries, Action <int> nonDiscardActionWithTimeout, Action discardAction) { if (Strategy == ThrottlingStrategy.None || waitingLogEntries < Limit) { nonDiscardActionWithTimeout(Timeout.Infinite); return; } if (Strategy == ThrottlingStrategy.Discard) { InternalLogger.Warn("[Syslog] Applied discard throttling strategy"); discardAction(); return; } ApplyDeferment(waitingLogEntries); nonDiscardActionWithTimeout(CalculateTimeout(waitingLogEntries)); }
private void TidyUp() { try { if (isReady) { Terminate(); } } catch (Exception exception) { InternalLogger.Warn(exception, "[Syslog] Terminate failed"); } finally { isReady = false; } }
/// <summary> /// Evaluates the expression. /// </summary> /// <param name="context">Evaluation context.</param> /// <returns>Expression result.</returns> public object Evaluate(LogEventInfo context) { try { return(this.EvaluateNode(context)); } catch (Exception exception) { InternalLogger.Warn(exception, "Exception occurred when evaluating condition"); if (exception.MustBeRethrownImmediately()) { throw; } throw new ConditionEvaluationException("Exception occurred when evaluating condition", exception); } }
protected override void CloseTarget() { InternalLogger.Warn("Closing {0} target", nameof(AzureBlobStorageLogTarget)); var result = _log.ShutdownAsync().GetAwaiter().GetResult(); if (!result.Succeeded) { InternalLogger.Error( result.Exception, "Failed to shutdown {0} target appropriately. Error: {1}", nameof(AzureBlobStorageLogTarget), result.Diagnostics ?? result.ErrorMessage ?? string.Empty); } else { InternalLogger.Info("Closed {0} target successfully", nameof(AzureBlobStorageLogTarget)); } }
protected override void Write(IList <AsyncLogEventInfo> logEvents) { if (!AuthTokenResolved()) { InternalLogger.Warn("auth token not resolved. skipping log entry."); return; } InternalLogger.Debug($"Sending {logEvents.Count} entries to endpoint: {Endpoint}"); using (var ms = new MemoryStream()) { using (var gzip = new GZipStream(ms, CompressionMode.Compress, true)) { using (var sw = new StreamWriter(gzip, _encoding, 1024, true)) { using (var jw = new JsonTextWriter(sw)) { var ser = JsonSerializer.Create(_logEntrySerializerSettings); foreach (var asyncLogEvent in logEvents) { try { SerializeLogEntry(jw, ser, asyncLogEvent.LogEvent); asyncLogEvent.Continuation(null); } catch (Exception ex) { InternalLogger.Error(ex, "Error writing Splunk log event"); asyncLogEvent.Continuation(ex); } } } } } ms.Position = 0; SendToEventCollector(ms); } }
public void WriteToStringWriterWithArgsTests() { // Expected result is the same for both types of method invocation. const string expected = "Warn WWW 0\nError EEE 0, 1\nFatal FFF 0, 1, 2\nTrace TTT 0, 1, 2\nDebug DDD 0, 1\nInfo III 0\n"; InternalLogger.LogLevel = LogLevel.Trace; InternalLogger.IncludeTimestamp = false; { StringWriter writer1 = new StringWriter() { NewLine = "\n" }; InternalLogger.LogWriter = writer1; // Named (based on LogLevel) public methods. InternalLogger.Warn("WWW {0}", 0); InternalLogger.Error("EEE {0}, {1}", 0, 1); InternalLogger.Fatal("FFF {0}, {1}, {2}", 0, 1, 2); InternalLogger.Trace("TTT {0}, {1}, {2}", 0, 1, 2); InternalLogger.Debug("DDD {0}, {1}", 0, 1); InternalLogger.Info("III {0}", 0); TestWriter(expected, writer1); } { // // Reconfigure the LogWriter. StringWriter writer2 = new StringWriter() { NewLine = "\n" }; InternalLogger.LogWriter = writer2; // Invoke Log(LogLevel, string) for every log level. InternalLogger.Log(LogLevel.Warn, "WWW {0}", 0); InternalLogger.Log(LogLevel.Error, "EEE {0}, {1}", 0, 1); InternalLogger.Log(LogLevel.Fatal, "FFF {0}, {1}, {2}", 0, 1, 2); InternalLogger.Log(LogLevel.Trace, "TTT {0}, {1}, {2}", 0, 1, 2); InternalLogger.Log(LogLevel.Debug, "DDD {0}, {1}", 0, 1); InternalLogger.Log(LogLevel.Info, "III {0}", 0); TestWriter(expected, writer2); } }
/// <summary> /// Create the mailmessage with the addresses, properties and body. /// </summary> private MailMessage CreateMailMessage(LogEventInfo lastEvent, string body) { var msg = new MailMessage(); var renderedFrom = this.From == null ? null : this.From.Render(lastEvent); if (string.IsNullOrEmpty(renderedFrom)) { throw new NLogRuntimeException(RequiredPropertyIsEmptyFormat, "From"); } msg.From = new MailAddress(renderedFrom); var addedTo = AddAddresses(msg.To, this.To, lastEvent); var addedCc = AddAddresses(msg.CC, this.CC, lastEvent); var addedBcc = AddAddresses(msg.Bcc, this.Bcc, lastEvent); if (!addedTo && !addedCc && !addedBcc) { throw new NLogRuntimeException(RequiredPropertyIsEmptyFormat, "To/Cc/Bcc"); } msg.Subject = this.Subject == null ? string.Empty : this.Subject.Render(lastEvent).Trim(); msg.BodyEncoding = this.Encoding; msg.IsBodyHtml = this.Html; if (this.Priority != null) { var renderedPriority = this.Priority.Render(lastEvent); try { msg.Priority = (MailPriority)Enum.Parse(typeof(MailPriority), renderedPriority, true); } catch { InternalLogger.Warn("Could not convert '{0}' to MailPriority, valid values are Low, Normal and High. Using normal priority as fallback."); msg.Priority = MailPriority.Normal; } } msg.Body = body; if (msg.IsBodyHtml && ReplaceNewlineWithBrTagInHtml && msg.Body != null) { msg.Body = msg.Body.Replace(EnvironmentHelper.NewLine, "<br/>"); } return(msg); }
protected override void Write(AsyncLogEventInfo logEvent) { GetConnection(); InternalLogger.Trace("Fluentd (Name={0}): Sending to address: '{1}:{2}'", Name, this.Host, this.Port); var record = new Dictionary <string, string>(); var logMessage = GetFormattedMessage(logEvent.LogEvent); record.Add("message", logMessage); try { this.emitter.Pack(logEvent.LogEvent.TimeStamp, this.Tag, record); } catch (Exception ex) { InternalLogger.Warn("Fluentd Emit - " + ex.ToString()); throw; // Notify NLog of failure } }
private Task ProcessQueueAsync(MessageBuilder messageBuilder, TaskCompletionSource <object> tcs) { if (token.IsCancellationRequested) { tcs.SetCanceled(); return(tcs.Task); } try { var asyncLogEventInfo = queue.Take(token); var logEventMsgSet = new LogEventMsgSet(asyncLogEventInfo, buffer, messageBuilder, messageTransmitter); logEventMsgSet .Build(layout) .SendAsync(token) .ContinueWith(t => { var exception = t.Exception; if (token.IsCancellationRequested || t.IsCanceled) { InternalLogger.Debug("[Syslog] Task canceled"); tcs.SetCanceled(); return; } if (exception != null) // t.IsFaulted is true { InternalLogger.Warn(exception.GetBaseException(), "[Syslog] Task faulted"); } else { InternalLogger.Debug("[Syslog] Successfully handled message '{0}'", logEventMsgSet); } ProcessQueueAsync(messageBuilder, tcs); }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Current); return(tcs.Task); } catch (Exception exception) { tcs.SetException(exception); return(tcs.Task); } }
/// <summary> /// Writes the specified log event to the wrapped target, retrying and pausing in case of an error. /// </summary> /// <param name="logEvent">The log event.</param> protected override void Write(AsyncLogEventInfo logEvent) { AsyncContinuation continuation = null; int counter = 0; continuation = ex => { if (ex == null) { logEvent.Continuation(null); return; } int retryNumber = Interlocked.Increment(ref counter); InternalLogger.Warn("Error while writing to '{0}': {1}. Try {2}/{3}", WrappedTarget, ex, retryNumber, RetryCount); // exceeded retry count if (retryNumber >= RetryCount) { InternalLogger.Warn("Too many retries. Aborting."); logEvent.Continuation(ex); return; } // sleep and try again (Check every 100 ms if target have been closed) for (int i = 0; i < RetryDelayMilliseconds;) { int retryDelay = Math.Min(100, RetryDelayMilliseconds - i); Thread.Sleep(retryDelay); i += retryDelay; if (!IsInitialized) { InternalLogger.Warn("Target closed. Aborting."); logEvent.Continuation(ex); return; } } WrappedTarget.WriteAsyncLogEvent(logEvent.LogEvent.WithContinuation(continuation)); }; WrappedTarget.WriteAsyncLogEvent(logEvent.LogEvent.WithContinuation(continuation)); }
private bool TryLoadLoggingConfiguration(LogFactory logFactory, string configFile, out LoggingConfiguration config) { try { #if SILVERLIGHT && !WINDOWS_PHONE Uri configFileUri = new Uri(configFile, UriKind.Relative); if (Application.GetResourceStream(configFileUri) != null) { config = LoadXmlLoggingConfiguration(logFactory, configFile); return(true); // File exists, and maybe the config is valid, stop search } #else if (File.Exists(configFile)) { config = LoadXmlLoggingConfiguration(logFactory, configFile); return(true); // File exists, and maybe the config is valid, stop search } #endif } catch (IOException ex) { InternalLogger.Warn(ex, "Skipping invalid config file location: {0}", configFile); } catch (UnauthorizedAccessException ex) { InternalLogger.Warn(ex, "Skipping inaccessible config file location: {0}", configFile); } catch (SecurityException ex) { InternalLogger.Warn(ex, "Skipping inaccessible config file location: {0}", configFile); } catch (Exception ex) { InternalLogger.Error(ex, "Failed loading from config file location: {0}", configFile); if (ex.MustBeRethrown()) { throw; } } config = null; return(false); // No valid file found }
/// <summary> /// Executes the received command by first parsing it then executing with the parsed values. /// </summary> /// <param name="command">The command<see cref="string"/></param> /// <returns>The <see cref="bool"/></returns> private static async Task <bool> ExecuteCommandAsync(string?command) { if (!InitCompleted) { Logger.Warn("Shell isn't initiated properly."); ShellIO.Error("Shell is offline!"); return(false); } if (string.IsNullOrEmpty(command)) { Logger.Trace("Command is null."); ShellIO.Error("Command empty or invalid."); return(false); } CurrentCommand = command; return(await ParseCommandAsync(command).ConfigureAwait(false)); }
/// <summary> /// Prefills command handlers. We cannot do it in runtime because there can be race conditions /// during initialization. Much simple just do that once on application start. /// </summary> protected override void Initialize() { // Precache all non-generic types with command handlers. commandHandlers = Assemblies.SelectMany(a => a.GetTypes()) .Where(t => HandlerSearchMethod == HandlerSearchMethod.ClassAttribute ? t.GetTypeInfo().GetCustomAttribute <CommandHandlersAttribute>() != null : t.Name.EndsWith("Handlers")) .SelectMany(t => t.GetTypeInfo().GetMethods()) .Where(m => m.GetParameters().Length > 0) .Where(m => m.Name.StartsWith(HandlerPrefix)) .ToArray(); if (!commandHandlers.Any()) { var assembliesStr = string.Join(",", Assemblies.Select(a => a.FullName)); InternalLogger.Warn(string.Format(Properties.Strings.NoHandlersInAssembly, assembliesStr), nameof(CommandHandlerLocatorMiddleware)); } }
/// <summary> /// Handles that scheduled task has completed (succesfully or failed), and starts the next pending task /// </summary> /// <param name="completedTask">Task just completed</param> /// <param name="continuation">AsyncContinuation to notify of success or failure</param> private void TaskCompletion(Task completedTask, object continuation) { try { if (ReferenceEquals(completedTask, _previousTask)) { if (TaskTimeoutSeconds > 0) { _taskTimeoutTimer.Change(Timeout.Infinite, Timeout.Infinite); } } else { if (!IsInitialized) { return; } } if (completedTask.IsCanceled) { if (completedTask.Exception != null) { InternalLogger.Warn(completedTask.Exception, "{0} WriteAsyncTask was cancelled", this.Name); } else { InternalLogger.Info("{0} WriteAsyncTask was cancelled", this.Name); } } else if (completedTask.Exception != null) { InternalLogger.Warn(completedTask.Exception, "{0} WriteAsyncTask failed on completion", this.Name); } var asyncContinuation = (AsyncContinuation)continuation; asyncContinuation(completedTask.Exception); } finally { TaskStartNext(completedTask); } }
private Task ProcessQueueAsync(MessageBuilder messageBuilder, TaskCompletionSource <object> tcs) { if (token.IsCancellationRequested) { return(tcs.CanceledTask()); } try { var asyncLogEventInfo = queue.Take(token); SignalFlushCompletionWhenIsMarker(asyncLogEventInfo); var logEventMsgSet = new LogEventMsgSet(asyncLogEventInfo, buffer, messageBuilder, messageTransmitter); logEventMsgSet .Build(layout) .SendAsync(token) .ContinueWith(t => { if (t.IsCanceled) { InternalLogger.Debug("Task canceled"); tcs.SetCanceled(); return; } if (t.Exception != null) // t.IsFaulted is true { InternalLogger.Warn(t.Exception.GetBaseException(), "Task faulted"); } else { InternalLogger.Debug("Successfully sent message '{0}'", logEventMsgSet); } ProcessQueueAsync(messageBuilder, tcs); }, token, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Current); return(tcs.Task); } catch (Exception exception) { return(tcs.FailedTask(exception)); } }
private void SetupMailMessage(MailMessage msg, LogEventInfo logEvent) { msg.From = new MailAddress(this.From.Render(logEvent)); foreach (string mail in this.To.Render(logEvent).Split(';')) { msg.To.Add(mail); } if (this.Bcc != null) { foreach (string mail in this.Bcc.Render(logEvent).Split(';')) { msg.Bcc.Add(mail); } } if (this.CC != null) { foreach (string mail in this.CC.Render(logEvent).Split(';')) { msg.CC.Add(mail); } } msg.Subject = this.Subject.Render(logEvent).Trim(); msg.BodyEncoding = this.Encoding; msg.IsBodyHtml = this.Html; if (this.Priority != null) { var renderedPriority = this.Priority.Render(logEvent); try { msg.Priority = (MailPriority)Enum.Parse(typeof(MailPriority), renderedPriority, true); } catch { InternalLogger.Warn("Could not convert '{0}' to MailPriority, valid values are Low, Normal and High. Using normal priority as fallback."); msg.Priority = MailPriority.Normal; } } }
/// <summary> /// Split the string and then compile into list of Rendering formats. /// </summary> /// <param name="formatSpecifier"></param> /// <returns></returns> private static List <ExceptionRenderingFormat> CompileFormat(string formatSpecifier) { List <ExceptionRenderingFormat> formats = new List <ExceptionRenderingFormat>(); string[] parts = formatSpecifier.Replace(" ", string.Empty).Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries); foreach (string s in parts) { ExceptionRenderingFormat renderingFormat; if (_formatsMapping.TryGetValue(s, out renderingFormat)) { formats.Add(renderingFormat); } else { InternalLogger.Warn("Unknown exception data target: {0}", s); } } return(formats); }
/// <summary> /// Renders the inner message, processes it and appends it to the specified <see cref="StringBuilder" />. /// </summary> /// <param name="builder">The <see cref="StringBuilder"/> to append the rendered data to.</param> /// <param name="logEvent">Logging event.</param> protected override void Append(StringBuilder builder, LogEventInfo logEvent) { if (Inner == null) { InternalLogger.Warn("{0} has no configured Inner-Layout, so skipping", this); return; } int orgLength = builder.Length; try { RenderInnerAndTransform(logEvent, builder, orgLength); } catch { builder.Length = orgLength; // Rewind/Truncate on exception throw; } }
/// <summary> /// Register NLog.Web.AspNetCore, so so <extension> in NLog's config isn't needed. /// </summary> internal static void RegisterNLogWebAspNetCore() { try { InternalLogger.Debug("Registering NLog.Web.AspNetCore"); ConfigurationItemFactory.Default.RegisterItemsFromAssembly(typeof(AspNetExtensions).GetTypeInfo().Assembly); } catch (Exception ex) { InternalLogger.Error(ex, "Registering NLog.Web.AspNetCore failed"); } try { LogManager.AddHiddenAssembly(typeof(NLogBuilder).GetTypeInfo().Assembly); } catch (Exception ex) { InternalLogger.Warn(ex, "Hidding assembly of {0} failed", nameof(NLogBuilder)); } }
void ShadePropertyChanged(object sender, PropertyChangedEventArgs e) { var shade = (Shade)sender; var index = _shadesSource.IndexOf(shade); if (index < 0) { InternalLogger.Warn(LogTag, $"ShadePropertyChanged => shade property {e.PropertyName} changed but we can't find the shade in the source"); return; } InternalLogger.Debug(LogTag, () => $"ShadePropertyChanged( shadeIndex: {index}, propertyName: {e.PropertyName} )"); switch (e.PropertyName) { case nameof(Shade.BlurRadius): case nameof(Shade.Color): case nameof(Shade.Offset): UpdateGeometry(); break; } }
private static JsonSerializerSettings CreateJsonSerializerSettings() { var jsonSerializerSettings = new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }; jsonSerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter()); jsonSerializerSettings.Converters.Add(new JsonToStringConverter(typeof(System.Reflection.MemberInfo))); jsonSerializerSettings.Converters.Add(new JsonToStringConverter(typeof(System.Reflection.Assembly))); jsonSerializerSettings.Converters.Add(new JsonToStringConverter(typeof(System.Reflection.Module))); jsonSerializerSettings.Error = (sender, args) => { InternalLogger.Warn(args.ErrorContext.Error, "GelfConverter: Error serializing property '{0}', property ignored", args.ErrorContext.Member); if (!LogManager.ThrowExceptions) { args.ErrorContext.Handled = true; } }; return(jsonSerializerSettings); }
private void TryAddGitRevisionId(Protobuf.Collections.MapField <string, string> labels) { try { var gitId = DevTools.Source.V1.SourceContext.AppSourceContext?.Git?.RevisionId; if (!String.IsNullOrWhiteSpace(gitId)) { labels.Add(DevTools.Source.V1.SourceContext.GitRevisionIdLogLabel, gitId); } } catch (Exception ex) when( ex is SecurityException || ex is InvalidProtocolBufferException || ex is InvalidJsonException || ex is UnauthorizedAccessException) { // This is best-effort only, exceptions from reading/parsing the source_context.json are ignored. InternalLogger.Warn(ex, "GoogleStackdriver(Name={0}): Exception at TryAddGitRevisionId", Name); } }
private Mutex CreateArchiveMutex() { try { return CreateSharableMutex("FileArchiveLock"); } catch (Exception ex) { if (ex is SecurityException || ex is UnauthorizedAccessException || ex is NotSupportedException || ex is NotImplementedException || ex is PlatformNotSupportedException) { InternalLogger.Warn(ex, "Failed to create global archive mutex: {0}", FileName); return new Mutex(); } InternalLogger.Error(ex, "Failed to create global archive mutex: {0}", FileName); if (ex.MustBeRethrown()) throw; return new Mutex(); } }
private void FindControlAndSendTheMessage(string logMessage) { Form form = null; if (Form.ActiveForm != null) { form = Form.ActiveForm; } if (Application.OpenForms[FormName] != null) { form = Application.OpenForms[FormName]; } if (form == null) { InternalLogger.Info("Form {0} not found", FormName); return; } Control control = FormHelper.FindControl(ControlName, form); if (control == null) { InternalLogger.Info("Control {0} on Form {1} not found", ControlName, FormName); return; } try { control.BeginInvoke(new DelSendTheMessageToFormControl(SendTheMessageToFormControl), control, logMessage); } catch (Exception ex) { InternalLogger.Warn(ex.ToString()); if (LogManager.ThrowExceptions) { throw; } } }
private static ExceptionDataTarget[] CompileFormat(string formatSpecifier) { string[] parts = formatSpecifier.Replace(" ", string.Empty).Split(','); var dataTargets = new List <ExceptionDataTarget>(); foreach (string s in parts) { switch (s.ToUpper(CultureInfo.InvariantCulture)) { case "MESSAGE": dataTargets.Add(AppendMessage); break; case "TYPE": dataTargets.Add(AppendType); break; case "SHORTTYPE": dataTargets.Add(AppendShortType); break; case "TOSTRING": dataTargets.Add(AppendToString); break; case "METHOD": dataTargets.Add(AppendMethod); break; case "STACKTRACE": dataTargets.Add(AppendStackTrace); break; default: InternalLogger.Warn("Unknown exception data target: {0}", s); break; } } return(dataTargets.ToArray()); }
private void CompileFormat(string format) { string[] parts = format.Replace(" ", "").Split(','); ArrayList dataTargets = new ArrayList(); foreach (string s in parts) { switch (s.ToLower()) { case "message": dataTargets.Add(new ExceptionDataTarget(AppendMessage)); break; case "type": dataTargets.Add(new ExceptionDataTarget(AppendType)); break; case "shorttype": dataTargets.Add(new ExceptionDataTarget(AppendShortType)); break; case "tostring": dataTargets.Add(new ExceptionDataTarget(AppendToString)); break; #if !NETCF case "stacktrace": dataTargets.Add(new ExceptionDataTarget(AppendStackTrace)); break; case "method": dataTargets.Add(new ExceptionDataTarget(AppendMethod)); break; #endif default: InternalLogger.Warn("Unknown exception data target: {0}", s); break; } } _exceptionDataTargets = (ExceptionDataTarget[])dataTargets.ToArray(typeof(ExceptionDataTarget)); }
/// <summary> /// Closes this instance. /// </summary> public override void Close() { InternalLogger.Trace("Closing '{0}'", FileName); try { if (fileStream != null) { fileStream.Dispose(); } } catch (Exception ex) { InternalLogger.Warn(ex, "Failed to close file '{0}'", FileName); System.Threading.Thread.Sleep(1); // Artificial delay to avoid hammering a bad file location } finally { fileStream = null; } FileTouched(); }
internal ILokiTransport GetLokiTransport(Layout endpoint) { var endpointUri = RenderLogEvent(endpoint, LogEventInfo.CreateNullEvent()); if (Uri.TryCreate(endpointUri, UriKind.Absolute, out var uri)) { if (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps) { var lokiHttpClient = LokiHttpClientFactory(uri); var httpLokiTransport = new HttpLokiTransport(uri, lokiHttpClient); return(httpLokiTransport); } } InternalLogger.Warn("Unable to create a valid Loki Endpoint URI from '{0}'", endpoint); var nullLokiTransport = new NullLokiTransport(); return(nullLokiTransport); }
/// <summary> /// Write to output /// </summary> /// <param name="textLine">text to be written.</param> private void WriteToOutput(string textLine) { if (_pauseLogging) { return; } var output = GetOutput(); try { output.WriteLine(textLine); } catch (IndexOutOfRangeException ex) { //this is a bug and therefor stopping logging. For docs, see PauseLogging property _pauseLogging = true; InternalLogger.Warn(ex, "An IndexOutOfRangeException has been thrown and this is probably due to a race condition." + "Logging to the console will be paused. Enable by reloading the config or re-initialize the targets"); } }
/// <summary> /// Creates the file stream. /// </summary> /// <param name="allowFileSharedWriting">If set to <c>true</c> sets the file stream to allow shared writing.</param> /// <returns>A <see cref="FileStream"/> object which can be used to write to the file.</returns> protected FileStream CreateFileStream(bool allowFileSharedWriting) { int currentDelay = this.CreateFileParameters.ConcurrentWriteAttemptDelay; InternalLogger.Trace("Opening {0} with allowFileSharedWriting={1}", this.FileName, allowFileSharedWriting); for (int i = 0; i < this.CreateFileParameters.ConcurrentWriteAttempts; ++i) { try { try { return(this.TryCreateFileStream(allowFileSharedWriting)); } catch (DirectoryNotFoundException) { if (!this.CreateFileParameters.CreateDirs) { throw; } Directory.CreateDirectory(Path.GetDirectoryName(this.FileName)); return(this.TryCreateFileStream(allowFileSharedWriting)); } } catch (IOException) { if (!this.CreateFileParameters.ConcurrentWrites || i + 1 == this.CreateFileParameters.ConcurrentWriteAttempts) { throw; // rethrow } int actualDelay = this.random.Next(currentDelay); InternalLogger.Warn("Attempt #{0} to open {1} failed. Sleeping for {2}ms", i, this.FileName, actualDelay); currentDelay *= 2; System.Threading.Thread.Sleep(actualDelay); } } throw new InvalidOperationException("Should not be reached."); }