serilog / serilog-sinks-rollingfile Goto Github PK

When creating a RollingFile Configuration, is their a good reason why you can not specify ITextFormatter like you use be able to?

If not I'll create a pull request.

Don't stop logging after the max file size has been reached, and the log file count is limited to 1 (e.g. when using date based rolling). Just clear the file and start new again.

Currently, if fileSizeLimitBytes is reached, Serilog simply stops logging, which is not acceptable (See https://github.com/serilog/serilog-sinks-file/blob/ea75e90815fb12075fa41040100806e791acc99d/src/Serilog.Sinks.File/Sinks/File/FileSink.cs#L83-L87).

The readme does not mention that there are now new pattern for the date specification {Hour} and {HalfHour}. Also it is not clear if the filecountlimit will stay at default 31 (my expectation) or if they are different. Like 24 for Hour and 48 for HalfHour to allways cover a day.

I was looking into moving our code from NLog to Serilog, but the rolling file sink is severly limited in comparison and probably a showstopper for us. (Even considering the alternative rolling file package)

First there are very few options, like choosing the period for a date-based rolling. E.g. having monthly files for a log that has few activity and long retention.

The lack of concurrent writes support is bad. As noted in the 2014 blog post, there was the IIS recycling issue. The split-file _001 trick is a hack but the worse is that retention is based on file count! So if one day I have issues and my app pool recycles like crazy, I'm going to loose all my log files! This doesn't seem ok to me.

I am tempted by all the cool Serilog structured logging features, but the rolling file sink is one (of two) blockers for me. It would be nice to port file target of NLog to Serilog, because it has plenty of options.

Now that Serilog.Sinks.File has gained more powerful features, I think it would be helpful for users to find some guidance and pointers about whether they should use one Sink or the other in new apps etc ... and also maybe different features supported in each.

Basically the comments that one can find in serilog/serilog-sinks-file#35 :)

Hi,

What's the best approach to restricting a log to a certain level? I see RollingFile has a restrictToMinimumLevel parameter, but if I wish to restrict the log data to only errors then I can't see this being an option. I recall there being a filter API which seems like it would be the next best thing.

Alternatively could you see much value in having a restrictToLevel property available on the method?

Isn't the rolling file supposed to tail entries and when file limit is reached delete lines from the head?

This isn't the case and the logger stops writing when the file limit is reached.

The README helpfully mentions the fileSizeLimitBytes parameter, which notifies us of default a maximum size on log files and allows us to configure it.

However, it's not clear what happens when the maximum is reached. Does Serilog rename the file that exceeds the limit? Does it delete it and create a new one? Does it create a new log with a different name? I don't see any need for elaborate details here, but a quick note would be helpful. E.g., if it depends on another parameter or is otherwise complex, just note the default and where all the gory details can be found.

The parameter's documentation comment is similarly unclear about the behavior.

This information is important because it will help users determine whether I need to alter the default or not. For example, if it gets deleted, I would probably disable it. If not, I would leave it alone.

Just wanna say thanks for this library. I like it much better than most other logging technologies I've seen/used. It's so much simpler.

I would like to know if we can log to multiple files in Serilog.
For example, i would like to create logs of TYPE1 to one file and TYPE2 to another file.

When i tried to create logger using following code:

var log = new LoggerConfiguration() .WriteTo.RollingFile("D:\\TM3171-TSRCoreModulesAnalysisDesign\\trunk\\B. Source Code\\Dapper-Postgres-Migrate-Test\\WEBAPI.Database\\ReadMe\\Date_Logs_2019-06-05.txt") .CreateLogger(); log.Information(error);

Installed package Serilog.Sinks.RollingFile

this code its not able to create any logger/Log file into my project

Hello,

We are having some trouble using the library because in some scenarios the UdpClient gets disposed before the message sending completes.
In the UdpClientTransport class the Send method creates the udpClient instance wrapped in the using directive. The returned Task is not executed and completed instantly resulting in disposing the udpClient instance which is still needed.
The actual result is getting an exception with the message: 'Cannot access a disposed object'.
.......
StackTrace
at System.Net.Sockets.Socket.EndSendTo(IAsyncResult asyncResult)
at System.Net.Sockets.UdpClient.EndSend(IAsyncResult asyncResult)
at System.Threading.Tasks.TaskFactory1.FromAsyncCoreLogic(IAsyncResult iar, Func2 endFunction, Action1 endAction, Task1 promise, Boolean requiresSynchronization)

Could you please take a look into this issue,

Thank you

Steps to reproduce:

• PathFormat must be by {date}
• Set fileSizeLimitBytes to let say 100000000.
• Start the app and let it create some logs
• Stop the app
• Open the newly created log file and add text until it weights more than 100MB
• Change the parameter fileSizeLimitBytes to 50000000
• Start the app and let it log... It won't do anything

Expected behavior:

• Since the file size limit had already been reached at the second app start, the sink should automatically create a new file names {date}_001.txt
• The sink should respect all other options as well (like the retainedFileCountLimit)

Hi.

First of all I want to give you congratulations for the good work.

The default (and only) {Date} specifier is very usefull for the most situations but now I have one need: to be able to generate more than one file per day. My problem is the big amount of data I am storing that causes to save big files or just ignore data once a daily file has reached the limit size.

One option I suggest could be to add a new {DateHour} specifier (maintaining the current {Date} specifier as the default one, assuring compatibility with previous versions) with the format "yyyyMMddHH" (24 hours format).

What do you think about it?

If you prefer I can do a PR.

Thank you.

Using .NET Core 2.0 WebAPI with Serilog and the RollingFile sink as such:

Packages (project.csproj):

    <PackageReference Include="Serilog.AspNetCore" Version="2.1.1" />
    <PackageReference Include="Serilog.Exceptions" Version="4.0.0" />
    <PackageReference Include="Serilog.Formatting.Compact" Version="1.0.0" />
    <PackageReference Include="Serilog.Settings.Configuration" Version="2.6.1" />
    <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
    <PackageReference Include="Serilog.Sinks.RollingFile" Version="3.3.0" />

Configuration File (logging.json):

{
  "Serilog": {
    "Using":  [
      "Serilog.Sinks.Console",
      "Serilog.Sinks.RollingFile"
    ],
    "MinimumLevel": {
      "Default": "Debug",
      "Override": {
        "Microsoft": "Information",
        "System": "Error"
      }
    },
    "WriteTo": [
      {
        "Name": "Console",        
        "Args": {
          "outputTemplate": "[{Timestamp} {Level:u3}] {Message:lj}{NewLine}{Exception}"
        },
      {
        "Name": "RollingFile",
        "Args": {
          "formatter": "Serilog.Formatting.Compact.CompactJsonFormatter, Serilog.Formatting.Compact",
          "pathFormat": "{Date}-FileHandlerLog.clef"
        }
      }
    ],
    "Enrich": [
      "FromLogContext",
      "WithExceptionDetails"
    ]
  }
}

Serilog Setup (program.cs):

      IConfigurationRoot config = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("logging.json", optional: true)
        .AddCommandLine(args)
        .Build();

      if (config.GetSection("Serilog").Exists()) {
        Log.Logger = new LoggerConfiguration()
          .ReadFrom.Configuration(config)
          .CreateLogger();
      }

Sometimes, when an exception is logged, the next attempt to log anything hangs indefinitely. However with the RollingFile sink disabled, everything operates as expected (no hangs). For this reason I feel there may be an issue with the RollingFile sink.

I'm using the following to initialize a rolling log file in the constructor of a web api controller:

` var path = HttpContext.Current.Server.MapPath("logs\log-{Date}.txt");

        var log = new LoggerConfiguration()
            .WriteTo.RollingFile(path)
            .CreateLogger();

        Log.Logger = log;`

This is working; however, rather than append new entries to the existing date, it's creating a new log file with the same name and "_001", "_002", "_003", etc appended to the end. Is there another way I should be initializing the rollingfile sink so that it only creates one file per day?

We have an Azure Web Service running an instance of IdentityServer3 and would like to do some logging. All works fine when running local, but when published to Azure through Visual Studio, the described folder "logs" is not created, and neither are the log file(s).

Any ideas on what might be in the way and keeping these items from being created?

Not using anything fancy...just the real basic setup:

Log.Logger = new LoggerConfiguration()
                .MinimumLevel.Debug()
                .WriteTo.LiterateConsole()
                .WriteTo.RollingFile(@"C:\logs\devs3server-{Date}.txt")
                .CreateLogger();

and Log.Information("Started logging.");

currently im able to split my logiles by static filters like:

Log.Logger = logger
.WriteTo.Async( a => a.Logger( lc => lc
.Filter.ByIncludingOnly( e => HasScope( e, "SomeScope" ) )
.WriteTo.Async( a2 => a2.RollingFile( $"{directory}{{Date}}_SomeScope.log" ) ) ) )
.CreateLogger();

what i would really like to do is something like:

Log.Logger = logger.WriteTo.Async( a2 => a2.RollingFile( $"{directory}{{Date}}_{{Scope}}.log", outputTemplate: template ) )
.CreateLogger();

meaning all properties in a logevent should be usable to modify the pathFormat and so the resulting path.

Is there any way I can pass blob storage URL path where to write the logs, with a rolling interval as day?

Hi, the doc says that it will insert {Date} into the file name by default if not provided, causing the rolling file to produce a log per day.

This is my first time using a rolling file, and I'm starting to think I misunderstood the concept. I thought the purpose of a rolling file was that if you hit a memory limit (say, 512000 bytes), then it will create a new file. If that file hits the limit, another new file is created until the maximum file limit is reached, which then wraps back around to overwrite the very first file (kind of like a snake eating its own tail).

It seems the way serilog-sinks-rollingfile works is that each day you have one log file, and with that one log file you can set a limit. If it hits the limit, it will no longer write to the file, and the user must wait until the next day for anything to be written (to a new file). Is this correct?

Is there a way I can make it work like the former scenario?

There is a parameter shared when creating a RollingFile sink.
But currently it's throwing a NotSupportedException when set to true.
See also

What's the status here?

• Is it working to write to one file from multiple processes even if this shared parameter is set to false?
• If not, will this be implemented?

Consider log output for a thread of ID, say, 15 when including the WithThreadId enricher and {ThreadId,5} in the ouputTemplate. The Console sink outputs the thread ID nicely pre padded to a total length of 5 ("   15"), but in the RollingFile sink outputs the thread ID and then 5 spaces ("15     ").

I would like them both to behave the same; the way the Console does it, which conforms to the .net formatting specifiers.

Hi I am looking all over for a way to configure multiple rolling files for specific log levels such as randomName-{Level}-{Date}.log

I cant seem to find anything only this issue #45
which defines the solution as a hard-coded one. I want specific level logging per each file.

Is this available and if not would it not make sense to add this?

I've currently got serilog set up in my Web API project to use the rolling file sink. It configures the logs in the Global.asax Application_Start like this:

        var webPath = HttpContext.Current.Server.MapPath("/logs/");
        var logLevel = ConfigurationManager.AppSettings.Get("LogLevel");

        switch (logLevel.ToLower())
        {
            case "warning":
                Log.Logger = new LoggerConfiguration()
                    .WriteTo.RollingFile(webPath + "BAH.API.Employee-{Date}.txt")
                    .MinimumLevel.Warning()
                    .CreateLogger();

                break;

            case "verbose":
                Log.Logger = new LoggerConfiguration()
                    .WriteTo.RollingFile(webPath + "BAH.API.Employee-{Date}.txt")
                    .MinimumLevel.Verbose()
                    .CreateLogger();

                break;

            case "information":
            default:
                Log.Logger = new LoggerConfiguration()
                    .WriteTo.RollingFile(webPath + "BAH.API.Employee-{Date}.txt")
                    .MinimumLevel.Information()
                    .CreateLogger();

                break;
        }

This works very well; however, there is one issue that I've been seeing... on occasion, it rolls the log file over and appends a "_001", "_002", etc. Is there a way to prevent this from happening? I thought at first that it had to do with the log files getting too big, but it'll sometimes roll them over when there is only a couple lines in there. Do I need to initialize the log file in a different way?

We have several scripts that run once daily. It would be handy to have a "Month" specifier so that there is exactly one log file per month.
Thank you for your time.

I want to use CSV format when logging so every generated file should have the fields as first line.

I think it would be nice if there was a file created event that allows to insert text.

Hello,
I have set max files size :500 MB . if the file reached to this size , there is no log added . So Is there a bility to create another file ?

Thanks

In my app, I want to be able to either open the log file from the UI and/or send the log file automatically to a backend server for further analysis.
However, it seems impossible to get hold of the current log filename.
Am I missing something here?

Hi, the current log file is locked until I stop the app service, is there any way to enable that I can either download the current log through ftp or by using "Clould Explorer" in Visual Studio without stopping the app first? I've tried setting the "shared: True" option but I get platform not supported (both locally and on Azure)

Hi,

Great job with this new feature! I have a problem now.. sometimes when I try to access the log file and read it with notepad, shows me an error that says the file is locked by another process.

This behaviour is because the new feature? There is a way to avoid it?

Thanks you!

Hi,
Our project is using Serilog2.3.0, Serilog.Sinks.ColoredConsole 2.0.0, Serilog.Sinks.File 3.1.1, Serilog.Sinks.RollingFile 3.2.0. However, i still see that the log/verbose files created for a day have numbers _001, _002, _003 etc attached next to filename-Date.

The way logger is configured is below:

There is a LoggingConfiguration class that calls to create the SeriLogger

public static ILogger Setup(ILogProvider logProvider, ConfigurationParameters configuration)
       {
           ILogger logger = logProvider.CreateLogger(configuration);

           logProvider.InternalSetup(logger);

           Log.Logger = logger;

           return logger;
       }

There is a class called SerilogProvider below with configuration method below:

private readonly LoggerConfiguration _loggerConfiguration;
 public ILogger CreateLogger(ConfigurationParameters configuration)
        {
            if (configuration != null)
            {
                Configure(configuration);
            }

            var logger = _loggerConfiguration.CreateLogger();

            return new SerilogLogger(logger);
        }

 public void InternalSetup(ILogger logger)
        {
            SerilogLibrary.Log.Logger = (logger as SerilogLogger)?.InternalLogger;
        }

private void Configure(ConfigurationParameters configurationParameters)
        {
  _loggerConfiguration
                .WriteTo
                .RollingFile(configurationParameters.ErrorLogFileName, LogEventLevel.Error, LoggingTemplate.Default,
                    retainedFileCountLimit: configurationParameters.ErrorLogRetentionDays);
}

This is being consumed as nuget package in the web api. The idea was to create a central logging web api but when i see these different versions of the files, it kind of negates the very purpose I am creating one. Should not different apps logging into this api be able to write into one single log file for a particular date?
Is there something I might be missing?

Thanks

Hey,
I configured my serilog in the app.config with these settings:

<add key="serilog:using:RollingFile" value="Serilog.Sinks.RollingFile" />
<add key="serilog:write-to:RollingFile.pathFormat" value="logs\log-{Date}.txt" />

Logger created with:
_logger = new LoggerConfiguration()
.ReadFrom.AppSettings()
.CreateLogger();

If i start the executable, serilog loggs to the directory where the .exe is placed.
But if i use Topfshelf and start the program as a service, serilog writes to "C:\Windows\SysWOW64\logs"

I want to configure the log-location in the appsettings, without environment variables.
Are there any ways?

Thank you!

Serilog.Sinks.File version 3.0.0 added auditing (.AuditTo) support. There shouldn't be much work in enabling it for rolling files as well.

We have a lot of legacy code whose log filenames have only 2 digits for the year (i.e. yyMMdd). We're adding new components written with .NET Core and need their log filenames to use the same; please consider adding the option to make that possible...

If following path is configured in the app settings.json "pathFormat": ".\log\applog-{Date}.log", which contains windows path notation, no log files get created when running it on linux or mac.

Regarding the {Date} specifier:

https://github.com/serilog/serilog-sinks-rollingfile/blob/master/src/Serilog.Sinks.RollingFile/Sinks/RollingFile/TemplatedPathRoller.cs#L56

If one doesn't add the {Date} specifier to the path, perhaps because the dev doesn't want the immutable format of yyyyMMdd, you add it automatically, and the dev ends up with two dates ... their own ... and your's tacked on at the end. I think if the dev doesn't add {Date} to the path, then you shouldn't presume to add it.

Hi,

By default we end up with:

log20180521.txt

Is it possible to vary that to say:

2018-05-21_log.txt

reason being we output all our logs to a common location with that format so adding one in via the rolling provider means it is not grouped together with the others.

We are creating a small console app which gets started by another process.
we want to add the existing log file, used by this application, as a rolling file sink.
however, if we provide our log file, for instance log20170830110754, it will create a new file with
log20170830110754-20170830.
We can't find the option to turn the datetime appendix off.

The shared option has been added to Serilog.Sinks.File via SharedFileSink in serilog/serilog-sinks-file#14. This paves the way for multi-process support here in the rolling file sink.

I believe that any logging framework should be overly pessimistic rather than optimistic. Since the last thing anyone wants to find is Serilog has deleted that log file you needed to troubleshoot from over a month ago.

Hi,

I was thinking about using this sync as fallback log with json formatter to create a structured log file(One log file per day). The ultimate goal is to try to log first into the database and if its unnacessible log into the fallback log: serilog-sinks-rollingfile. On the next day i would like to put all this log into the DB and delete the past log file. Are there any tips on how to do this? How can i know which is the current log file? How about multi-processes reading/writing into the log file?

Thanks!

Would like to add Specifiers to split log files by custom defined rules.
For example on log level, context or other properties.

What are people's thoughts on adding an optional parameter to the RollingFile method to disable the rolling file log?

In this instance, as I'm setting up rolling file logging via an appsettings, using the following configuration:

  "Serilog": {
    "WriteTo": [
      {
        "Name": "RollingFile",
        "Args": {
          "pathFormat": "log-{Date}.txt",
          "retainedFileCountLimit": 3,
          "shared": true
        }
      }
    ]
  }

It would be really handy to disable rolling file logging in development in my appsettings.development.json file.

I'm more than happy to contribute this change if you feel it's one that would be valuable.

Hello,

I see that it's forbidden to use specifiers as the part of the directory name. I wonder if there's a chance you could allow to use at least Date specifier? Or is there any other ways to log to date folders?

Thank you in advance

When I run the Nuget command: Install-Package Serilog.Sinks.RollingFile
I get the following error:

PM> Install-Package Serilog.Sinks.RollingFile
Attempting to gather dependencies information for package 'Serilog.Sinks.RollingFile.3.0.0' with respect to project 'AntPad', targeting '.NETFramework,Version=v4.5.2'
Install-Package : An error occurred while retrieving package metadata for 'Serilog.2.2.1' from source 'C:\Users\Antw\Source\Repos\AntPad\AntPad\packages'.
At line:1 char:1
+ Install-Package Serilog.Sinks.RollingFile
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Install-Package], Exception
    + FullyQualifiedErrorId : NuGetCmdletUnhandledException,NuGet.PackageManagement.PowerShellCmdlets.InstallPackageCommand

Our current application logging is using log4net which has a nice (for us) behavior to start with a fresh file every time you run an application.
It works like this:

• You run application and a new log file called for example application.log is created
• If there is an old application.log file it's renamed to application.log.1.
• If there is an old application.log.1 file it's renamed to application.log.2, etc.
• If log file size reaches defined threshold it creates a new application.log and renames all older files according to schema described above.

Having this behavior available in Serilog would be great. While file-per-day is useful in some scenarios it can be difficult to find when application started. In lot of cases some important work is being done during start and that's when you need to investigate log messages. If you know that they are always at the beginning of the log it saves you a lot of time.

That's what I'm currently experiencing.

When deleting the logfile while the server is still running, I'm expecting the running server to recreate the log file.

Currently I'd have to restart the server (ouch) just to get the logfile back again.

Question : Is there any plan to include Rolling file based on size/date in this sink. AlternateRollingFileSink does not have option to specify the retainedFileCount and there is no development/pr happening on that sink. I am curious to know if this will be included here.

Update : AlternateRollingFileSink now supports Retenation policy and also ITextFormatter if anyone is looking for the same

I have the issue that I have an application that runs days or weeks until it get's restarted.
And what happens is that I get a logfile with the date the application was started in the name.
But also logs from the following days go to the same logfile until I restart the application, than the new date log file is created.

Is it possible that this sink, checks that?

{
"Name": "RollingFile", // 滚动文件
"Args": {
"pathFormat": "logs\{level}\log-{Date}.txt"
}
}

is there possible to support separate log by leg level

Hello,

Given the following setup in an ASP.Net website startup:

var builder = new ContainerBuilder();
builder.Register(c => ConfigureLogger()).As<ILogger>();
builder.Build();


    public static ILogger ConfigureLogger()
    {
        var level = new LoggingLevelSwitch(LogEventLevel.Debug);
        var filePath = ConfigurationManager.AppSettings["serilog:Log:FilePath"] +
            $"RequirementsWS_{Environment.MachineName}_";
        return Log.Logger = new LoggerConfiguration()
            .MinimumLevel.ControlledBy(level)
            .Enrich.FromLogContext()
            .Enrich.WithMachineName()
            .Enrich.WithThreadId()
            .WriteTo.Seq(ConfigurationManager.AppSettings["serilog:write-to:Seq.serverUrl"],
                apiKey: ConfigurationManager.AppSettings["serilog:write-to:Seq.apiKey"],
                controlLevelSwitch: level,
                compact: true)
            .WriteTo.RollingFile(filePath + "{Date}.log",
                outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message}{NewLine}{Exception}")
            .CreateLogger();
    }

I'm wondering what might be causing multiple files to be generated as shown in the attached screenshot.

Thank you,
Stephen