Logging using Serilog

Use one of the Nodinite Serilog sinks with your full framework and .NET Core applications to enable end-to-end tracking. Microsoft Azure functions built with .NET (usually CSharp) are typical. Nodinite sports payload Logging and removes the obstacle the Application insights logging imposes on message size.

🚀 Why Choose Nodinite Logging Over Application Insights & Competing Solutions?

In today’s fast-paced business environments, logging and monitoring are not just about collecting data—they're about gaining actionable insights without losing valuable context. While tools like Application Insights and other logging platforms require predefined logic to capture key values (such as order numbers or correlation IDs), Nodinite Logging takes a different approach—one that eliminates guesswork, prevents data loss, and enhances long-term flexibility.

Nodinite integrates seamlessly with Serilog, offering specialized sinks for both on-premise and cloud-based solutions. Unlike other logging solutions, Nodinite can log any payload size, whereas Application Insights and many competitors impose strict limitations.

Nodinite Logging vs. Application Insights & Other Competitors

1. Full Payload Logging—No Predefined Logic Needed

• With Nodinite, you don’t need to code up-front logic to extract key values like correlation IDs, order numbers, or transaction details.
• All message payloads and context values are logged in full, ensuring you always have complete visibility into your data.
• With Application Insights and other tools, if you forget to log a value, it’s lost forever. With Nodinite, you can extract and index new fields at any time!

🔑 Key Advantage: No need for developers to anticipate every possible logging requirement—just log everything and extract later when the need arises.

2. Flexible Search & Reindexing – No More Data Loss

• In most competing solutions, if you realize you need a new search field, it’s too late—the data has already been logged without that key information.
• With Nodinite, you can create new search fields anytime and reindex old data without losing any historical context.
• If a field extraction was incorrect? Just fix the expression and reindex—no lost data!

🔑 Key Advantage: No risk of data loss due to changing business needs or human error in defining log fields.

3. Serilog-Based Logging for On-Prem & Cloud

• Nodinite provides dedicated Serilog sinks for both on-premise and cloud environments, offering seamless integration with your existing logging infrastructure.
• Works effortlessly with .NET applications, containerized solutions, and cloud-native services.

🔑 Key Advantage: Native Serilog integration means no need to change your logging framework—just plug in Nodinite and start logging smarter.

4. No Payload Size Limitations

• Application Insights and many competitors impose strict size limits on logged data, often truncating valuable information when payloads exceed the allowed size.
• With Nodinite, there are no payload size restrictions—log full messages, large transactions, and complex payloads without worrying about data loss.

🔑 Key Advantage: Capture complete logs, no matter how large the payload.

5. Granular, Message-Type Level Retention

• Competing solutions often limit retention based on fixed days or data volume quotas, forcing businesses to choose between losing valuable logs or paying excessive storage fees.
• Nodinite allows you to define retention per message type, so high-value business transactions (e.g., financial transactions, critical orders) can be kept longer, while less important logs are purged earlier.

🔑 Key Advantage: Optimize retention based on business value, not arbitrary time limits or storage constraints.

🔥 The Bottom Line: Why Nodinite Wins

✅ Small effort upfront coding needed—log everything and extract key values later.
✅ No data loss—reindex old data anytime, even if requirements change.
✅ Native Serilog integration—works with existing logging frameworks.
✅ No payload size limits—log full messages without truncation.
✅ Granular retention control—keep critical logs longer without excessive costs.

💡 With Nodinite, you never have to say "I wish we had logged that." Everything is available when you need it.

You can choose to use any of the available Nodinite Serilog sinks, which are easily accessible on NuGet:

#	Sink	Authentication	Reliable Messaging	Message Size	Latest version
1.	Log API	Integrated Windows Authentication		>=0B
2.	Azure Event Hub	Managed IdentitiyNew 2.0.0 Connection string		<1024KB
3.	Azure Service Bus	Managed IdentitiyNew 2.0.0 Connection string		<256KB
4.	Azure Blob Storage ContainerNew 2.0.14	Managed Identitiy Connection string		>=0B	NuGet
5.	File (SMB)	Integrated Windows Authentication		>=0B	NuGet

Develop Azure Functions using Visual Studio

Log Event

The Nodinite Serilog sink produces a Nodinite JSON Log Event which then the Nodinite Pickup Log Events Service Logging Agent consumes.

The JSON Log Event has three distinct parts:

1. Event details (also named Additional field values within Nodinite)
2. Payload (Body, 0 or more)
3. Context properties (Key/Value)

Info

Please review the Nodinite Pickup Service for additional information.

1. Details

The following mandatory fields must be set, either in configuration or with code (values are example data and should be replaced with your logic):

Info

The specified values are merely example data.

Review the JSON Log Event user guide for details about the optional fields.

2. Payload

If you want to log the payload (body), then please add it as plain text in the context property "body".

3. Context Properties

The following optional coded context properties are mapped if present to the following Nodinite "additional field values":

Review the Context Options user guide for additional features overriding the default behaviour.

Automatically assigned

The following properties are automatically assigned by the Nodinite Serilog sink:

Log Status Code translation table

The Nodinite Log Status Codes are translated as described in the table below from the following Serilog Log Levels:

Step-by-step guide

The example assumes you are adding the Logging to an Azure function. However, it should be pretty straightforward to use this example for other project types.

You must add code and perform operations as follows:

1: Add NuGet Package Reference

From Visual Studio, add to your Solution a package reference to one of the Nodinite Serilog sinks.

NuGet package manager example, filtered by Nodinite packages.

2: Program.cs

In the startup of your project, you need to perform two main tasks:

1. Add configuration
2. Initialize the Logger

1. Add configuration

You have two options, either add the fields in the code; or have them in the Settings.json.

1. Add configuration by code
2. Add configuration from the Settings file

Add configuration by code

The following example adds the configuration with code.

var connectionString = "Endpoint=sb://yournamespace.servicebus.windows.net/;SharedAccessKeyName=Default;SharedAccessKey=%hidden%;EntityPath=apieh";
  var settings = new NodiniteLogEventSettings()
  { 
      LogAgentValueId = 503, 
      EndPointDirection = 0, 
      EndPointTypeId = 0, 
      EndPointUri = "Nodinite.Serilog.Sink.Tests.Serilog", 
      EndPointName = "Nodinite.Serilog.Sink.Tests", 
      OriginalMessageTypeName = "Serilog.LogEvent", 
      ProcessingUser = "NODINITE", 
      ProcessName = "Nodinite.Serilog.Sink.Tests", 
      ProcessingMachineName = "NODINITE-DEV", 
      ProcessingModuleName = "DOTNETCORE.TESTS", 
      ProcessingModuleType = "DOTNETCORE.TESTPROJECT" 
  };

Add configuration from the settings file

The following example adds the configuration using a settings file.

var configuration = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .Build();

Sample appsettings.json file Below is an example for the NodiniteEventHubSink, change as required.

Replace <%NodiniteSinkName%> with any of the following (depending on which package you opted for):

• AzureBlobStorageSink - Managed Identity
• AzureBlobStorageSinkWithConnectionString
• NodiniteApiSink
• NodiniteFileSink
• NodiniteServiceBusSink
• NodiniteEventHubSink

{
  "Serilog": {
    "Using": [ "<placeholder>" ],
    "WriteTo": [
      {
        "Name": "NodiniteEventHubSink",
        "Args": {
          "ConnectionString": "*******************************",
          "Settings": {
            "LogAgentValueId": 503,
            "EndPointName": "Nodinite.Serilog.Sink.Tests",
            "EndPointUri": "Nodinite.Serilog.Sink.Tests.Serilog",
            "EndPointDirection": 0,
            "EndPointTypeId": 0,
            "OriginalMessageTypeName": "Serilog.LogEvent",
            "ProcessingUser": "NODINITE",
            "ProcessName": "Nodinite.Serilog.Sink.Tests",
            "ProcessingMachineName": "NODINITE-DEV",
            "ProcessingModuleName": "DOTNETCORE.TESTS",
            "ProcessingModuleType": "DOTNETCORE.TESTPROJECT"
          }
        }
      }
    ]
  }
}

2. Initialize the Logger

Now in the Startup.cs file it is time to create the actual singleton logger.

If you added the configuration by code, please use the following example:

var logger = new LoggerConfiguration()
    .WriteTo.NodiniteEventHubSink(connectionString, settings)
    .CreateLogger();

builder.Services.AddSingleton<ILogger, Serilog.Core.Logger>(sp => logger);

Otherwise, if you added the configuration from a settings file, please use the following example:

        var logger = new LoggerConfiguration()
            .ReadFrom.Configuration(configuration)
            .CreateLogger();
   
        services.AddSingleton<ILogger, Logger>(sp => logger);

3: Perform Logging

In your code, you must add a call to perform the Logging. The example includes the full payload together with some context data (key-value).

You are supposed to extend this sample with additional fields according to your requirements. Make sure to set a proper name for the Message Type as this is crucial to Nodinite.

private void Log(string correlationId, string payload)
{
   _logger.ForContext(new PropertyEnricher("ApplicationInterchangeId", $"{correlationId}"))
       .ForContext(new PropertyEnricher("Body", JsonConvert.SerializeObject(payload)))
       .ForContext(new PropertyEnricher("OriginalMessageType", "OrderMessage#1.0"))
       .ForContext(new PropertyEnricher("LogStatusCode", -1337))
       .ForContext("Body", "{\"id\":1}")
       .Information("Hello from Function");
} 

^{New 2.0.18}
If you want to log multiple bodies (Attachments), instead of Body, you can use Bodies and send a list of strings like in the following example.

.ForContext("Bodies", "[{\"id\":1},{\"id\":2}]")

Note

If you also pass a payload using the Body field, the Bodies are treated as attachments. Hence, the OriginalMessageType is applied on the Body. If you only pass Bodies, the OriginalMessageType is applied on the 1st entry in the list.

^{New 2.0.23} You can override the LogStatus regardless of the type of log (i.e. .Information, .Warning, ...).

4: Cleanup

Before exiting the thread/run/invocation/... please call the Dispose method on the Logger as we are utilizing a singleton pattern.

Put this code after the last Logging operation.

((Logger)_logger).Dispose();

.NET Exceptions

^{New 1.3.0}

If you log an Exception, for example using the LogError( method, the Nodinite sink adds it to the Context. The name of the Context key is ExtendedProperties/1.0#Exception.

From Nodinite, you can then use the Formula plugin to create Search Fields and extract whatever information you seek from the Exception.

Example extracting the Message part of an exception.

JsonPath('..Message', Context('ExtendedProperties/1.0#Exception'))

Tip

The Exception can include nested exceptions.

Next Step

Log Events
JSON Log Event

Related Topics

Logging