Sample .Net Core Service HostingWindows Service, Linux daemon, Google Cloud Compute Engine

Today I am going to look at implementing .Net Core Generic Service Host and host it in .Net Core app to run as daemon under Linux. We will use Google.Cloud.Logging.NLog library to integrate NLog with Stackdriver. See "Integrating NLog with Stackdriver for error reporting on Google Cloud" for more details. App will be deployed on Google Cloud Compute Engine VM running Linux and will run as daemon service. In this sample service I will run a thread that will post an information message to Google Logging Interface. The sample code for this project is hosted on github.

We will create sample_service_hosting .Net core console project, which will implement our SampleService that will post messages to Google Logging Interface.

1. Create sample_service_hosting .Net Core console project

>mkdir sample_service_hosting
>cd sample_service_hosting
>dotnet new console

Add the following package references

	<ItemGroup>
	<PackageReference Include="Google.Cloud.Logging.NLog" Version="2.1.0" />
	<PackageReference Include="Microsoft.Extensions.Configuration" Version="2.2.0" />
	<PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="2.2.0" />
	<PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.2.0" />
	<PackageReference Include="Microsoft.Extensions.Hosting" Version="2.2.0" />
	<PackageReference Include="Microsoft.Extensions.Logging" Version="2.2.0" />
	<PackageReference Include="Microsoft.Extensions.Logging.Configuration" Version="2.2.0" />
	<PackageReference Include="Microsoft.Extensions.Logging.Console" Version="2.2.0" />
	<PackageReference Include="nlog" Version="4.6.6" />
	<PackageReference Include="NLog.Extensions.Hosting" Version="1.5.2" />
	</ItemGroup>

view raw sshost_packagerefs.csproj hosted with ❤ by GitHub

NLog, NLog.Extensions.Hosting and Google.Cloud.Logging.NLog are also added for a final stage of the project to support logging messages to Google Cloud Log Viewer.

2. Implement HostBuilder configuration

Now we are going to implement HostBuilder, which will run our Generic Host with RunAsync call. I normally create it in the separate CreateHostBuilder function. It will return null if for some reason we failed to create our generic host and in Main we will need to check for returned result.

	using System.IO;
	using System.Threading.Tasks;
	using Microsoft.Extensions.Configuration;
	using Microsoft.Extensions.DependencyInjection;
	using Microsoft.Extensions.Hosting;
	using Microsoft.Extensions.Logging;
	using NLog.Extensions.Hosting;
	namespace VSC
	{
	class Program
	{
	static async Task Main(string[] args)
	{
	IHostBuilder hostBuilder = CreateHostBuilder(args);
	if(hostBuilder != null)
	{
	IHost host = hostBuilder.Build();
	await host.RunAsync();
	}
	}
	private static IHostBuilder CreateHostBuilder(string[] args)
	{
	try
	{
	var builder = new HostBuilder()
	.ConfigureAppConfiguration((hostingContext, config) =>
	{
	config.SetBasePath(Directory.GetCurrentDirectory());
	config.AddJsonFile("appsettings.json", optional: true);
	config.AddJsonFile(
	$"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json",
	optional: true);
	config.AddCommandLine(args);
	})
	.ConfigureServices((hostContext, services) =>
	{
	services.AddHostedService<Services.SampleService>();
	services.Configure<HostOptions>(option =>
	{
	option.ShutdownTimeout = System.TimeSpan.FromSeconds(20);
	});
	})
	.ConfigureLogging((hostingContext, logging) =>
	{
	logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
	logging.AddConsole();
	});
	return builder;
	}
	catch { }
	return null;
	}
	}
	}

view raw sshost_CreateHostBuilder.cs hosted with ❤ by GitHub

You notices that we adding appsettings.json file as well. Lets add it to our project.

	{
	"Logging": {
	"LogLevel": {
	"Default": "Trace",
	"Microsoft": "Information"
	}
	}
	}

view raw sshost_appsettings.json hosted with ❤ by GitHub

And a SampleService class, which we will extend in the next section. Add SampleService.cs under Services folder.

	using System;
	using System.Threading;
	using System.Threading.Tasks;
	using Microsoft.Extensions.Hosting;
	namespace VSC.Services
	{
	public class SampleService : IHostedService, IDisposable
	{
	public void Dispose()
	{
	// TODO: Do service clean up here
	}
	public Task StartAsync(CancellationToken cancellationToken)
	{
	// TODO: Do work here
	return Task.CompletedTask;
	}
	public Task StopAsync(CancellationToken cancellationToken)
	{
	// stop service processes here
	return Task.CompletedTask;
	}
	}
	}

view raw SampleService.cs hosted with ❤ by GitHub

3. Implement SampleService hosted service

In this section we are going to inject nlog into our generic host builder and extend our SampleService host to log message every 10 seconds. We already configured HostBuilder to inject logger in ConfigureLogging section. We need to add .UseNLog() call just after var builder = new HostBuilder() in CreateHostBuilder function. In the SampleService class we will use CancellationTokenSource to cancel our service and stop Run thread when IsCancellationRequested is true. Run function will be called asynchronously and pointer to Task object is saved.

	using System;
	using System.Threading;
	using System.Threading.Tasks;
	using Microsoft.Extensions.Hosting;
	using Microsoft.Extensions.Logging;
	namespace VSC.Services
	{
	public class SampleService : IHostedService, IDisposable
	{
	private CancellationTokenSource _cancellationTokenSource;
	private Task _executingTask;
	ILogger<SampleService> _logger;
	public SampleService(
	ILogger<SampleService> logger
	)
	{
	_logger = logger;
	}
	public void Dispose()
	{
	// TODO: Do service clean up here
	}
	public Task StartAsync(CancellationToken cancellationToken)
	{
	_logger.LogTrace("SampleService StartAsync method called.");
	_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
	_executingTask = Run(_cancellationTokenSource.Token);
	return Task.CompletedTask;
	}
	public async Task StopAsync(CancellationToken cancellationToken)
	{
	_logger.LogTrace("SampleService StopAsync method called.");
	// Stop called without start
	if (_executingTask == null)
	{
	return;
	}
	// stop service processes here
	_cancellationTokenSource.Cancel();
	_logger.LogInformation("Sample Service stopped.");
	// Wait until the task completes or the stop token triggers
	await Task.WhenAny(_executingTask, Task.Delay(-1, cancellationToken));
	}
	private async Task Run(CancellationToken cancellationToken)
	{
	_logger.LogTrace("Starting iteration count Run");
	await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
	int iterationCount = 0;
	while (!cancellationToken.IsCancellationRequested)
	{
	iterationCount++;
	_logger.LogInformation(string.Format("Running round {0}", iterationCount));
	await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken);
	}
	}
	}
	}

view raw sshost_SampleService1.cs hosted with ❤ by GitHub

Logger is logging Trace messages and information messages within iteration loop. Add nlog.config to project.

	<?xml version="1.0" encoding="utf-8" ?>
	<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	autoReload="true"
	internalLogLevel="info">
	<!-- enable asp.net core layout renderers -->
	<extensions>
	<add assembly="NLog.Web.AspNetCore"/>
	</extensions>
	<!-- the targets to write to -->
	<targets>
	<!-- write logs to file -->
	<target name="asyncLogFile" xsi:type="AsyncWrapper">
	<target
	xsi:type="File"
	name="logfile"
	fileName="log/log-${shortdate}.txt"
	archiveFileName="log/archive/log-${shortdate}.txt"
	keepFileOpen="true"
	archiveAboveSize="20000000"
	concurrentWrites="false"
	archiveEvery="Day"
	layout="${longdate}|${uppercase:${level}}|${logger}|${message} ${exception:format=tostring}" />
	</target>
	<target name="asyncConsole" xsi:type="AsyncWrapper">
	<target name="console" xsi:type="ColoredConsole"
	layout="${date} ${threadname:whenEmpty=${threadid}} ${level:uppercase=true} ${logger} ${message} ${onexception:${exception}}" />
	</target>
	</targets>
	<!-- rules to map from logger name to target -->
	<rules>
	<!--All logs-->
	<logger name="*" minlevel="Trace" writeTo="asyncLogFile" />
	<logger name="*" minlevel="Info" writeTo="asyncConsole" />
	<logger name="Microsoft.*" maxLevel="Info" final="true" /> <!-- BlackHole without writeTo -->
	</rules>
	</nlog>

view raw sshost_nlog1.config hosted with ❤ by GitHub

4. Enabling gradual stop of the service on SIGTERM signal

We can deploy this sample_service_hosting app to Linux VM and make it run as a daemon, but with its current implementation it will not properly respond to SIGTERM sent from Linux host to gradually stop and clean up used resources. For this we are going to use injected IApplicationLifetime object and register events ApplicationStarted, ApplicationStopping and ApplicationStoped.

	using System;
	using System.Threading;
	using System.Threading.Tasks;
	using Microsoft.Extensions.Hosting;
	using Microsoft.Extensions.Logging;
	namespace VSC.Services
	{
	public class SampleService : IHostedService, IDisposable
	{
	private CancellationTokenSource _cancellationTokenSource;
	private Task _executingTask;
	IApplicationLifetime _appLifetime;
	ILogger<SampleService> _logger;
	public SampleService(
	ILogger<SampleService> logger,
	IApplicationLifetime appLifetime
	)
	{
	_logger = logger;
	_appLifetime = appLifetime;
	}
	public void Dispose()
	{
	// TODO: Do service clean up here
	}
	public Task StartAsync(CancellationToken cancellationToken)
	{
	_logger.LogTrace("SampleService StartAsync method called.");
	_appLifetime.ApplicationStarted.Register(OnStarted);
	_appLifetime.ApplicationStopping.Register(OnStopping);
	_appLifetime.ApplicationStopped.Register(OnStopped);
	_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
	_executingTask = Run(_cancellationTokenSource.Token);
	return Task.CompletedTask;
	}
	public async Task StopAsync(CancellationToken cancellationToken)
	{
	_logger.LogTrace("SampleService StopAsync method called.");
	// Stop called without start
	if (_executingTask == null)
	{
	return;
	}
	// stop service processes here
	_cancellationTokenSource.Cancel();
	_logger.LogInformation("Sample Service stopped.");
	// Wait until the task completes or the stop token triggers
	await Task.WhenAny(_executingTask, Task.Delay(-1, cancellationToken));
	}
	private void OnStarted()
	{
	_logger.LogTrace("SampleService OnStarted method called.");
	// Post-startup code goes here
	}
	private void OnStopping()
	{
	_logger.LogTrace("SampleService OnStopping method called.");
	// On-stopping code goes here
	}
	private void OnStopped()
	{
	_logger.LogTrace("SampleService OnStopped method called.");
	// Post-stopped code goes here
	}
	private async Task Run(CancellationToken cancellationToken)
	{
	_logger.LogTrace("Starting iteration count Run");
	await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
	int iterationCount = 0;
	while (!cancellationToken.IsCancellationRequested)
	{
	iterationCount++;
	_logger.LogInformation(string.Format("Running round {0}", iterationCount));
	await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken);
	}
	}
	}
	}

view raw sshost_SampleService2.cs hosted with ❤ by GitHub

5. NLog.config - Add support for Stackdriver logging

At the start we already added reference to Google.Cloud.Logging.NLog package. Now we need to update nlog.config file to include assembly Google.Cloud.Logging.NLog and GoogleStackdriver target to log to Google Logging Interface.

	<?xml version="1.0" encoding="utf-8" ?>
	<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	autoReload="true"
	internalLogLevel="info">
	<!-- enable asp.net core layout renderers -->
	<extensions>
	<add assembly="NLog.Web.AspNetCore"/>
	<add assembly="Google.Cloud.Logging.NLog"/>
	</extensions>
	<!-- the targets to write to -->
	<targets>
	<!-- write logs to file -->
	<target name="asyncLogFile" xsi:type="AsyncWrapper">
	<target
	xsi:type="File"
	name="logfile"
	fileName="log/log-${shortdate}.txt"
	archiveFileName="log/archive/log-${shortdate}.txt"
	keepFileOpen="true"
	archiveAboveSize="20000000"
	concurrentWrites="false"
	archiveEvery="Day"
	layout="${longdate}|${uppercase:${level}}|${logger}|${message} ${exception:format=tostring}" />
	</target>
	<target name="asyncConsole" xsi:type="AsyncWrapper">
	<target name="console" xsi:type="ColoredConsole"
	layout="${date} ${threadname:whenEmpty=${threadid}} ${level:uppercase=true} ${logger} ${message} ${onexception:${exception}}" />
	</target>
	<target name="asyncStackDriver" xsi:type="AsyncWrapper">
	<target name="stackDriver"
	xsi:type="GoogleStackdriver"
	logId="Default"
	layout="${longdate}|${uppercase:${level}}|${logger}|${message} ${exception:format=tostring}" />
	</target>
	</targets>
	<!-- rules to map from logger name to target -->
	<rules>
	<!--All logs-->
	<logger name="*" minlevel="Trace" writeTo="asyncLogFile" />
	<logger name="*" minlevel="Info" writeTo="asyncConsole" />
	<logger name="*" minlevel="Trace" writeTo="asyncStackDriver" />
	<logger name="Microsoft.*" maxLevel="Info" final="true" /> <!-- BlackHole without writeTo -->
	</rules>
	</nlog>

view raw sshost_nlog2.config hosted with ❤ by GitHub

Conclusion

Our sample_service_hosting app is done. Check the final version of this project on github. I am not going to cover here setup of this app as a daemon on Linux VM Google Cloud Compute Engine. This will be a topic of separate blog post. Stay tuned. 

References:

• Clean service stop by handling SIGTERM on Linux with .NET Core 2.1
• Integrating NLog with Stackdriver for error reporting on Google Cloud

Integrating NLog with Stackdriver for error reporting on Google Cloud

In this post I will create a .net core console app, which will be hosted on Google Cloud Compute Engine VM running Debian Linux console only OS. For this we are going to use Google.Cloud.Logging.NLog .NET client library to integrate Google Stackdriver Logging with NLog. The sample code for this app is hosted on github repository.

Lets create our .Net Core console app project

>mkdir nlog_with_stackdriver
>cd nlog_with_stackdriver
>dotnet new console

Run 'dotnet build' and 'dotnet run' to see if our new project builds and runs successfully.

Now we need to add NLog and  Google.Cloud.Logging.NLog packages.

>dotnet add package nlog
>dotnet add package Google.Cloud.Logging.NLog packages

Create nlog.config file

	<?xml version="1.0" encoding="utf-8" ?>
	<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	autoReload="true"
	internalLogLevel="info">
	<extensions>
	<add assembly="Google.Cloud.Logging.NLog"/>
	</extensions>
	<!-- the targets to write to -->
	<targets>
	<target name="asyncConsole" xsi:type="AsyncWrapper">
	<target name="console"
	xsi:type="ColoredConsole"
	layout="${date} ${threadname:whenEmpty=${threadid}} ${level:uppercase=true} ${logger} ${message} ${onexception:${exception}}" />
	</target>
	<target name="asyncStackDriver" xsi:type="AsyncWrapper">
	<target name="stackDriver"
	xsi:type="GoogleStackdriver"
	logId="Default"
	layout="${longdate}|${uppercase:${level}}|${logger}|${message} ${exception:format=tostring}" />
	</target>
	</targets>
	<!-- rules to map from logger name to target -->
	<rules>
	<!--All logs-->
	<logger name="*" minlevel="Trace" writeTo="asyncConsole" />
	<logger name="*" minlevel="Trace" writeTo="asyncStackDriver" />
	<logger name="Microsoft.*" maxLevel="Info" final="true" /> <!-- BlackHole without writeTo -->
	</rules>
	</nlog>

view raw nlog_stackdriver.config hosted with ❤ by GitHub

Important to note the use of assembly Google.Cloud.Logging.NLog and in asyncStackDriver target I used logId as "Default". LogId can be set to be the name of the console app or the project.

In the project file include ItemGroup to copy nlog.config file to output directory during build and publish.

	<ItemGroup>
	<None Include="nlog.config" CopyToOutputDirectory="Always" />
	<ItemGroup>

view raw copy_to_output_dir.csproj hosted with ❤ by GitHub

Add the following code to Main.

	static void Main(string[] args)
	{
	Logger logger = LogManager.GetCurrentClassLogger();
	// Log some information. This log entry will be sent to Google Stackdriver Logging.
	logger.Info("An exciting log entry for Google Cloud!");
	// Flush buffered log entries before program exit; then shutdown the logger before program exit.
	LogManager.Flush(TimeSpan.FromSeconds(15));
	LogManager.Shutdown();
	}

view raw nlog_with_stackdriver_Main.cs hosted with ❤ by GitHub

At the end of the program before closing it is important to Flush resources and Shutdown the logger. Windows 10 gives limited time for application to close and under linux as well as Windows important to clear and close external resources used. In our case we are using Google Cloud Logging Agent.

Now our sample app is competed and ready to deploy to Google Cloud Computer Engine VM. Looks like it should just magically work. We do not need provide any authentication with Google Cloud, nor we do not need to specify project ID in nlog.config. When running from within Compute Engine VM Google.Cloud.Logging.NLog will detect all needed settings and just run. But here is a catch...

We need to install Google Cloud Logging Agent on our Debian virtual machine.

>curl -sSO https://dl.google.com/cloudagents/install-logging-agent.sh
>sudo bash install-logging-agent.sh

References:

• Google.Cloud.Logging.NLog
• Stackdriver Agent
• Google Cloud Logging NLog target
• NLog Configuration Options
• NLog Best Practice

Code format and beautifier for code snippets in blogger.com

In almost all my blog posts I show code snippets or command line examples. To make code examples more readable they need to have code highlighting. One very nice and easy option that I liked for code highlighting is to use github gists. On my github I created one multi-file gist. To include only one file from multi-file gist use code sample below. Replace name before js with one provided by gist’s tag. Replace FileName with name of the file in the gist.

	<script src="https://gist.github.com/[you_github_username]/[paste name from script tag].js?file=FileName">
	</script>

view raw include_gist.html hosted with ❤ by GitHub

The sample of commands I like to show in the sample box that is not prettifying the text. Use the sample code below to wrap the sample command between “pre” tags.

	<pre class="code-font" style="background-color: #f5f6f7; border: 1px solid rgb(210, 211, 215); font-size: 13px; font-weight: normal; line-height: 2em; overflow: auto; padding: 1em; vertical-align: baseline; word-wrap: break-word;">
	</pre>

view raw command_sample_box.html hosted with ❤ by GitHub

Example of the sample command box.

C:\run_me.exe