NeonService Class

public abstract class NeonService : IDisposable

Public MustInherit Class NeonService
	Implements IDisposable

public ref class NeonService abstract : IDisposable

[<AbstractClassAttribute>]
type NeonService =  
    class
        interface IDisposable
    end

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Neon.Common;
using Neon.Service;

namespace Service_Basic
{
    public static class Program
    {
        public async static Task Main(string[] args)
        {
            // Launch the service.

            await new MyService().RunAsync();
        }
    }

    public class MyService : NeonService
    {
        public MyService() : base("my-service")
        {
        }

        /// <inheritdoc/>
        protected override void Dispose(bool disposing)
        {
            // This is where you should dispose thing like your webapp, 
            // database connections, etc.

            base.Dispose(disposing);
        }

        protected async override Task<int> OnRunAsync()
        {
            // You can retrieve configuration settings from environment variables
            // or files passed by Kubernetes, Docker, or unit tests via these
            // base clase methods:

            var mySetting    = GetEnvironmentVariable("MY_SETTING");
            var myConfigPath = GetConfigFilePath("/my-config.yaml");

            // Use this base class property to log things.  These will be picked up
            // automatically by Kubernetes and Docker.

            Log.LogInfo("HELLO WORLD!");

            // This is where your service does its thing: like starting a webapp,
            // process data from queues, implementing a database, or whatever.
            // Note that there's no need to wrap this code with a try...catch
            // to log exceptions because the base class already does that for you.
            // 
            // We're just going to do pretend by doing nothing here except for 
            // wait for a termination signal from Kubernetes, Docker, or the unit
            // test framework.

            await Task.Delay(TimeSpan.FromDays(365), Terminator.CancellationToken);

            // Return a non-zero exit code when the service terminates normally.

            return 0;
        }
    }
}

protected override Dispose(bool disposing)
{
    base.Dispose(disposing);

    if (appHost != null)
    {
        appHost.Dispose();
        appHost = null;
    }
}

LogManager.Default.SetLogLevel(LogLevel.Debug));

NEON_SERVICE_DEPENDENCIES_URIS=http://foo.com;tcp://10.0.0.55:1234
NEON_SERVICE_DEPENDENCIES_TIMEOUT_SECONDS=30
NEON_SERVICE_DEPENDENCIES_WAIT_SECONDS=5

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Neon.Common;
using Neon.Service;

namespace Service_Dependencies
{
    public static class Program
    {
        public async static Task Main(string[] args)
        {
            // Construct the service and configure it to wait for another
            // become available before calling the services [OnRunAsync()]
            // method.  This is useful for situations where a collection
            // of related services are started at the same time (e.g. via
            // docker-compose or Kubernetes Helm charts giving the service
            // service being relied on a chance to start before this service 
            // tries to access it.
            // 
            // This can also be an issue when using Istio/Envoy sidecars
            // in Kubernetes because the Envoy pod sidecar often takes longer
            // to start than the service, meaning that the network will be
            // unavailable for few seconds.
            // 
            // We've effectively implemented the retry logic so you don't
            // have to.

            var service = new MyService();

            service.Dependencies.Uris.Add(new Uri("http://waitforthis.com"));

            // You can control how long to wait before a [TimeoutException]
            // will be thrown.  This defaults to 120 seconds.

            service.Dependencies.Timeout = TimeSpan.FromSeconds(30);

            // You can optionally wait longer after the dependencies are ready.

            service.Dependencies.Wait = TimeSpan.FromSeconds(10);

            await new MyService().RunAsync();
        }
    }

    public class MyService : NeonService
    {
        public MyService() : base("my-service")
        {
        }

        /// <inheritdoc/>
        protected override void Dispose(bool disposing)
        {
            // The http://waitforthis.com endpoint will be ready at this point.

            base.Dispose(disposing);
        }

        protected async override Task<int> OnRunAsync()
        {
            await Task.Delay(TimeSpan.FromDays(365), Terminator.CancellationToken);

            return 0;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Neon.Common;
using Neon.Service;

namespace Service_Dependencies
{
    public static class Program
    {
        public async static Task Main(string[] args)
        {
            // Construct the service and configure it to wait for another
            // become available before calling the services [OnRunAsync()]
            // method.  This is useful for situations where a collection
            // of related services are started at the same time (e.g. via
            // docker-compose or Kubernetes Helm charts giving the service
            // service being relied on a chance to start before this service 
            // tries to access it.
            // 
            // This can also be an issue when using Istio/Envoy sidecars
            // in Kubernetes because the Envoy pod sidecar often takes longer
            // to start than the service, meaning that the network will be
            // unavailable for few seconds.
            // 
            // We've effectively implemented the retry logic so you don't
            // have to.

            var service = new MyService();

            service.Dependencies.Uris.Add(new Uri("http://waitforthis.com"));

            // You can control how long to wait before a [TimeoutException]
            // will be thrown.  This defaults to 120 seconds.

            service.Dependencies.Timeout = TimeSpan.FromSeconds(30);

            // You can optionally wait longer after the dependencies are ready.

            service.Dependencies.Wait = TimeSpan.FromSeconds(10);

            await new MyService().RunAsync();
        }
    }

    public class MyService : NeonService
    {
        public MyService() : base("my-service")
        {
        }

        /// <inheritdoc/>
        protected override void Dispose(bool disposing)
        {
            // The http://waitforthis.com endpoint will be ready at this point.

            base.Dispose(disposing);
        }

        protected async override Task<int> OnRunAsync()
        {
            await Task.Delay(TimeSpan.FromDays(365), Terminator.CancellationToken);

            return 0;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;

using Neon.Common;
using Neon.Service;

using Prometheus;       // From the [prometheus-net] nuget package

namespace Service_Metrics
{
    public static class Program
    {
        public async static Task Main(string[] args)
        {
            // You can enable Prometheus metrics with just one line of code!
            // 
            // This enables scraping mode where the service is configured as an
            // exporter that Prometheus can scrape periodically on port [9762],
            // the standard NeonService metrics port.
            // 
            // You can customize this port using the [MetricsOptions.Port]
            // property to avoid port conflicts by we recommend standarizing 
            // on the default port when running in a container where port
            // conflicts won't be an issue.
            // 
            // You can also configure the service to push metrics to a
            // Prometheus Pushgateway but doing this should be limited
            // to special situations.  See the Prometheus documentation 
            // for more information.

            var service = new MyService();

            service.MetricsOptions.Mode = MetricsMode.Scrape;

            await new MyService().RunAsync();
        }
    }

    public class MyService : NeonService
    {
        // Define a custom Prometheus counter.  This value will be able to be
        // tracked on Prometheus related dashboards, alert rules, etc.
        public static Counter runTimeCounter = Metrics.CreateCounter("run-time", "Service run time in seconds.");

        public MyService() : base("my-service")
        {
        }

        /// <inheritdoc/>
        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }

        protected async override Task<int> OnRunAsync()
        {
            // We're just increment the runtime counter once a second until
            // see see the termination signal.

            while (!Terminator.CancellationToken.IsCancellationRequested)
            {
                await Task.Delay(TimeSpan.FromSeconds(1));
                runTimeCounter.Inc();
            }

            return 0;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;

using Neon.Common;
using Neon.Service;

using Prometheus;               // From the [prometheus-net] nuget package
using Prometheus.DotNetRuntime; // From the [prometheus-net.DotNetRuntime] nuget package

namespace Service_RuntimeMetrics
{
    public static class Program
    {
        public async static Task Main(string[] args)
        {
            var service = new MyService();

            service.MetricsOptions.Mode = MetricsMode.Scrape;

            // For .NET Core 2.2+ based services, we highly recommend that you enable
            // collection of the .NET Runtime metrics as well to capture information
            // about threads, memory, exceptions, JIT statistics, etc.  You can do this
            // with just one more statement:

            service.MetricsOptions.GetCollector = () => 
                DotNetRuntimeStatsBuilder
                    .Default()
                    .StartCollecting();

            // The line above collects all of the available runtime metrics.  You can 
            // customize which metrics are collected using this commented line, but
            // we recommend collecting everything because you never know when you'll
            // need it:

            //service.MetricsOptions.GetCollector = () =>
            //    DotNetRuntimeStatsBuilder
            //        .Customize()
            //        .WithContentionStats()
            //        .WithJitStats()
            //        .WithThreadPoolSchedulingStats()
            //        .WithThreadPoolStats()
            //        .WithGcStats()
            //        .WithExceptionStats()
            //        .StartCollecting();

            await new MyService().RunAsync();
        }
    }

    public class MyService : NeonService
    {
        public static Counter runTimeCounter = Metrics.CreateCounter("run-time", "Service run time in seconds.");

        public MyService() : base("my-service")
        {
        }

        /// <inheritdoc/>
        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }

        protected async override Task<int> OnRunAsync()
        {
            while (!Terminator.CancellationToken.IsCancellationRequested)
            {
                await Task.Delay(TimeSpan.FromSeconds(1));
                runTimeCounter.Inc();
            }

            return 0;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;

using Neon.Common;
using Neon.Service;

using Prometheus;               // From the [prometheus-net] nuget package
using Prometheus.DotNetRuntime; // From the [prometheus-net.DotNetRuntime] nuget package

namespace Service_FullMealDeal
{
    public static class Program
    {
        public async static Task Main(string[] args)
        {
            var service = new MyService();

            service.Dependencies.Uris.Add(new Uri("http://waitforthis.com"));

            service.MetricsOptions.Mode = MetricsMode.Scrape;
            service.MetricsOptions.GetCollector = () => 
                DotNetRuntimeStatsBuilder
                    .Default()
                    .StartCollecting();

            await new MyService().RunAsync();
        }
    }

    public class MyService : NeonService
    {
        public static Counter runTimeCounter = Metrics.CreateCounter("run-time", "Service run time in seconds.");

        public MyService() : base("my-service")
        {
        }

        /// <inheritdoc/>
        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }

        protected async override Task<int> OnRunAsync()
        {
            while (!Terminator.CancellationToken.IsCancellationRequested)
            {
                await Task.Delay(TimeSpan.FromSeconds(1));
                runTimeCounter.Inc();
            }

            return 0;
        }
    }
}