Blog

Every so often I have the need to rename a massive amount of files. This generally happens when there is a pattern in the name and I need to change it to a different pattern.

There are a number of ways to do this, but I often use the following short script to do it. Simply modify the patterns to fit the current need.

# A little script to perform a mass renaming of files.
# Adjust accordingly.
for file in [0-3][0-9].md; do
        echo git mv "$file" "2022.02.$file"
done

And now for a completely useless post.

A long time ago in a world without internet typing characters was a premium.¹ To account for this premium most applications would use command line options that had a single characters. A good example of this is the "verbose" option. Tradditionally this was indicated with a -v on the command line.

As time went by there were situations where two options had the same first character. One way around this was to just use another letter for the option. An example of this might be the option -a. This might represent the intent to "append". Or it might represent the option for "add" or "all". Using -p, -d or -l to represent an alternative just doesn't seem like a choice that makes sense to someone that isn't familiar with the options.

As resources became "cheaper" and more plentiful the practice of expanding the characters used for an option became more common. Instead of use the -v for "verbose" the entire word might be used. The -v would now be represented by --verbose. The use of two dashes² are used to indicate that the option is a full word and not a single character.

It was also common practice to use aliases when a full word could be used or the single letter could be used to indicate the same parameter. In the case of a "verbose" option it is possible to use either the -v syntax or the --verbose syntax to indicate the option.

---

Footnotes

1: Computers were "slow" and had limited memory. Also, programmers are notoriously "lazy". They want to type as little as possible to get to where they need to go.↩

2: Not to be confused with the empty double dash -- which is used to indicate the end of command line processing.↩

Create new project from template

Using the dotnet new command, create a application based upon the console template.

iesoftwaredeveloper:~/repos$ dotnet new console --output SimpleCmdLine/src --name SimpleCmdLine
The template "Console Application" was created successfully.

Processing post-creation actions...
Running 'dotnet restore' on SimpleCmdLine/src/SimpleCmdLine.csproj...
  Determining projects to restore...
  Restored /Users/iesoftwaredeveloper/repos/SimpleCmdLine/src/SimpleCmdLine.csproj (in 66 ms).
Restore succeeded.
iesoftwaredeveloper:~/repos$

Once the dotnet new command has completed you will should have a new directory called SimpleCmdLine in the current directory. Change to the new directory and then the src directory and then list the files that were created.

iesoftwaredeveloper:~/repos$ cd SimpleCmdLine
iesoftwaredeveloper:~/repos$ cd src
iesoftwaredeveloper:~/repos$ ls
Program.cs      SimpleCmdLine.csproj
iesoftwaredeveloper:~/repos$

You can see that the template created two files. The first is the project file SimpleCmdLine.csproj and the other is the main file for the project called Program.cs.

Add a .gitignore and README

To help ensure that we avoid committing files that we don't usually want in our git repos we should create a .gitignore file. Fortunately, dotnet can help us create a simple .gitignore that will accommodate some common files when developing using Visual Studio. If you are using Visual Studio Code the same .gitignore will also apply. If you are using a different Integrated Development Environment (IDE) or using a simple text editor then you will still benefit from creating the .gitignore using this method. Many of the items are created as part of the dotnet commands.

To create a dotnet focused .gitignore using the dotnet new gitignore command. While we are here I will create a basic README.md as well.

Note: The readme template is not installed by default. If you do not have it installed then dotnet will search NuGet for a matching template. I installed the template from author Rodolpho Alves named "Readme (Markdown)". You can install it using the command dotnet new -i ARDC.Commons.Templates::0.2.1 This is entirely optional and you can certainly just manually create your own README.md

iesoftwaredeveloper:~/repos/SimpleCmdLine$ dotnet new gitignore
The template "dotnet gitignore file" was created successfully.
iesoftwaredeveloper:~/repos/SimpleCmdLine$ dotnet new readme
The template "Readme (Markdown)" was created successfully.
iesoftwaredeveloper:~/repos/SimpleCmdLine$ 

If you open your .gitignore you will see that it has been populated with a myriad of rules to help avoid committing files you probably do not want in your repository.

Nothing is more frustrating to a software developer than phantom errors. It is the the wasted hours over some insignificant piece of code that was working and suddenly doesn't and you can't seem to see anything wrong with it.

I present the following as an example. Take this very simple piece of sample code from the dotnet documentation used to demonstrate dependency injection. It is a very simple application that uses DI to pass a method to a service.

Now slightly modify the example to add Serilog to enable structured logging. Again not a complicated snippet of code. This is the code in all of its glory that was created as a simple demonstration program.

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Serilog;
using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

namespace DependencyInjection.Example
{
    class Program
    {
        static async Task<int> Main(string[] args)
        {
            // Bootstrap logger
            Log.Logger = new LoggerConfiguration()
            .MinimumLevel.Debug()
            .Enrich.FromLogContext()
            .WriteTo.Console(outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj} {Properties}{NewLine}{Exception}")
            .CreateBootstrapLogger();

            try
            {
                // Create Cancellation tokens 
                CancellationTokenSource source = new CancellationTokenSource();
                CancellationToken token = source.Token;

                Console.CancelKeyPress += (s, e) =>
                {
                    Log.Information("Cancelling...");
                    source.Cancel();
                    e.Cancel = true;
                };

                Log.Information("Starting host");
                await CreateHostBuilder(args).Build().RunAsync(token);

                Log.Information("Stopping host");
                return 0;
            }
            catch (Exception ex)
            {
                Log.Fatal(ex, "An unhandled exception occurred during bootstrapping");
                return 1;
            }
            finally
            {
                Log.Information("Closing and flushing logs");
                Log.CloseAndFlush();
            }
        }

        static IHostBuilder CreateHostBuilder(string[] args)
        {
            return Host.CreateDefaultBuilder(args)
                    .ConfigureAppConfiguration((hostContext, configApp) =>
                    {
                        Log.Debug("Configuring App Configuration");
                        configApp.SetBasePath(Directory.GetCurrentDirectory());
                        configApp.AddJsonFile("appsettings.json", optional: true);
                        configApp.AddJsonFile(
                            $"appsettings.{hostContext.HostingEnvironment.EnvironmentName ?? Environments.Production}.json",
                            optional: false);
                        configApp.AddEnvironmentVariables(prefix: "SMAPPLY_");
                        configApp.AddCommandLine(args);
                    })
                    .UseSerilog((context, services, configuration) =>
                    {
                        configuration.ReadFrom.Configuration(context.Configuration).ReadFrom.Services(services);
                    })
                    .ConfigureServices((_, services) =>
                        services.AddHostedService<Worker>()
                            .AddScoped<IMessageWriter, MessageWriter>());
        }
    }
}

And now you simply run the program using dotnet run and you should get a simple running example with some output to the console.

2021-05-13 17:50:52.838 -07:00 [INF] Starting host {}
2021-05-13 17:50:52.922 -07:00 [DBG] Configuring App Configuration {}
2021-05-13 17:50:53.230 -07:00 [DBUG] Hosting starting {EventId={Id=1, Name="Starting"}, SourceContext="Microsoft.Extensions.Hosting.Internal.Host", EnvironmentName="Production"}
2021-05-13 17:50:53.236 -07:00 [INFO] Worker running at: 05/13/2021 17:50:53 -07:00 {SourceContext="DependencyInjection.Example.Worker", EnvironmentName="Production"}
2021-05-13 17:50:53.238 -07:00 [INFO] Application started. Press Ctrl+C to shut down. {SourceContext="Microsoft.Hosting.Lifetime", EnvironmentName="Production"}
2021-05-13 17:50:53.238 -07:00 [INFO] Hosting environment: Production {SourceContext="Microsoft.Hosting.Lifetime", EnvironmentName="Production"}
2021-05-13 17:50:53.238 -07:00 [INFO] Content root path: /Users/rll04747/src/repos/GenericHost {SourceContext="Microsoft.Hosting.Lifetime", EnvironmentName="Production"}
2021-05-13 17:50:53.238 -07:00 [DBUG] Hosting started {EventId={Id=2, Name="Started"}, SourceContext="Microsoft.Extensions.Hosting.Internal.Host", EnvironmentName="Production"}
2021-05-13 17:50:54.241 -07:00 [INFO] Worker running at: 05/13/2021 17:50:54 -07:00 {SourceContext="DependencyInjection.Example.Worker", EnvironmentName="Production"}
2021-05-13 17:50:55.242 -07:00 [INFO] Worker running at: 05/13/2021 17:50:55 -07:00 {SourceContext="DependencyInjection.Example.Worker", EnvironmentName="Production"}
^C2021-05-13 17:50:56.062 -07:00 [INFO] Cancelling... {EnvironmentName="Production"}
2021-05-13 17:50:56.063 -07:00 [INFO] Application is shutting down... {SourceContext="Microsoft.Hosting.Lifetime", EnvironmentName="Production"}
2021-05-13 17:50:56.066 -07:00 [DBUG] Hosting stopping {EventId={Id=3, Name="Stopping"}, SourceContext="Microsoft.Extensions.Hosting.Internal.Host", EnvironmentName="Production"}
2021-05-13 17:50:56.069 -07:00 [DBUG] Hosting stopped {EventId={Id=4, Name="Stopped"}, SourceContext="Microsoft.Extensions.Hosting.Internal.Host", EnvironmentName="Production"}
2021-05-13 17:50:56.072 -07:00 [INFO] Stopping host {EnvironmentName="Production"}
2021-05-13 17:50:56.073 -07:00 [INFO] Closing and flushing logs {EnvironmentName="Production"}

Unfortunately, instead what you get is an error message stating that you can't inject a Scoped IMessageWriter into a Singleton HostedService Worker. To frustrate you even more, you can't even reproduce the error when you try to write a blog post about it. Instead you get the error that you wish you had received in the first place to help you solve the issue quickly. Oh the joys of being a Software Developer.

Since I am unable to reproduce the error you will have to accept that the error was as I describe above. You can't inject a Scoped service into a Singleton Hosted service. This error generally makes sense to me dealing with differently scoped services. In this particular case however it was exactly what the sample code from the csharp documentation was doing. After staring at the screen, removing lots of code and generally going mad, I decided to start an entirely new project from scratch. I recreated the example from the documentation line by line and execute the `dotnet run`. Success! It works. feelings of defeat. I quickly run a `diff` between the two programs. They are some minor differences. The example code references `System.Exception` while my code only references `Exception`. That doesn't seem to be a significant change. However, just to be safe, I will change mine to explicitly reference `System.Exception` and try again.

If only it were that easy. For some reason my code still doesn't want to run and throws the exception each time I run it. At this point the only difference is the use of `Serilog` in my code. Well the obvious next step is to add Serilog to the working example code and watch it fail. So I make some quick edits to the working example and run it. It fails...NOT! The two files match literally and my code is still failing while the example code blissfully runs. Mocking me and ensuring that I will be absolutely unproductive for the remainder of the day. Seems like the only decent thing to do.

So what could be different between the two that is causing my code to fail while the example works? The only other code that is different is the appsettings.config files. Let us compare those. No those appear to be exactly the same too. sinks into even deeper feeling of defeat. Right about now the talking to yourself and cursing at how there must clearly be a bug in the system, not my software begins to increase in volume.

I frantically make changes the appsettings.json file as well as the appsettings.Production.json file that are used to configure Serilog. Nothing seems to fix my code and nothing seems to break the example code., then suddenly my code begins to work seemingly out of nowhere.

In the appsettings.Production.json file there was one additional entry in the `Using` section. The working example contained the following configuration.

    "Using": [
      "Serilog.Exceptions",
      "Serilog.Sinks.Console",
      "Serilog.Sinks.Seq"
    ]

The configuration file I was using contained this entry.

    "Using": [
      "Serilog.Exceptions",
      "Serilog.Sinks.Console",
      "Serilog.Sinks.Slack",
      "Serilog.Sinks.Seq"
    ]

Notice the slight difference. My configuration contains a reference to a Slack sink for Serlog that I had been using previously during some testing. Which during this previous testing my code was working I will add. After adding in the Seq and deciding to send slack messages from Seq instead of from the code directly I decided to remove the Slack Sink from the code. To do this I removed all references to the Slack assembly as well. However, I had apparently not removed it from the configuration file. In my several attempts to actually fix my code I had removed it from the appsettings.json file without success. I can't be sure, but in removing it one or several things must have occurred. After removing it I may not have saved the file before running the code. This resulted in no change occurring since the code was reading the version of the file with the reference in it. The other possibility is that I modified the wrong appsettings.json. This of course would have the same result of not saving the changes.

So why wasn't this obvious to me. Well, because the exception I received didn't say anything about Slack or Serilog or anything about the appsettings.conf. Instead it told me I couldn't inject a scoped service into a singleton service.

While attempting to reproduce the error for this post I reintroduced the Slack reference and ran the code. Did it fail? It sure did. And it produced the following exception.

2021-05-14 07:43:13.419 -07:00 [INFO] Starting host {}
2021-05-14 07:43:13.482 -07:00 [DBUG] Configuring App Configuration {}
2021-05-14 07:43:13.700 -07:00 [FATL] An unhandled exception occurred during bootstrapping {}
System.IO.FileNotFoundException: Could not load file or assembly 'Serilog.Sinks.Slack, Culture=neutral, PublicKeyToken=null'. The system cannot find the file specified.

File name: 'Serilog.Sinks.Slack, Culture=neutral, PublicKeyToken=null'
   at System.Reflection.RuntimeAssembly.InternalLoad(ObjectHandleOnStack assemblyName, ObjectHandleOnStack requestingAssembly, StackCrawlMarkHandle stackMark, Boolean throwOnFileNotFound, ObjectHandleOnStack assemblyLoadContext, ObjectHandleOnStack retAssembly)
   at System.Reflection.RuntimeAssembly.InternalLoad(AssemblyName assemblyName, RuntimeAssembly requestingAssembly, StackCrawlMark& stackMark, Boolean throwOnFileNotFound, AssemblyLoadContext assemblyLoadContext)
   at System.Reflection.Assembly.Load(AssemblyName assemblyRef)
   at Serilog.Settings.Configuration.ConfigurationReader.LoadConfigurationAssemblies(IConfigurationSection section, AssemblyFinder assemblyFinder)
   at Serilog.Settings.Configuration.ConfigurationReader..ctor(IConfigurationSection configSection, AssemblyFinder assemblyFinder, IConfiguration configuration)
   at Serilog.ConfigurationLoggerConfigurationExtensions.Configuration(LoggerSettingsConfiguration settingConfiguration, IConfiguration configuration, String sectionName, DependencyContext dependencyContext)
   at Serilog.ConfigurationLoggerConfigurationExtensions.Configuration(LoggerSettingsConfiguration settingConfiguration, IConfiguration configuration, DependencyContext dependencyContext)
   at SMApply.CLI.Program.<>c.<CreateHostBuilder>b__1_1(HostBuilderContext context, IServiceProvider services, LoggerConfiguration configuration) in /Users/rll04747/src/repos/SMApply/SMApply.CLI.WTF/Program.cs:line 109
   at Serilog.SerilogHostBuilderExtensions.<>c__DisplayClass3_2.<UseSerilog>b__4(LoggerConfiguration cfg)
   at Serilog.Extensions.Hosting.ReloadableLogger.Reload(Func`2 configure)
   at Serilog.SerilogHostBuilderExtensions.<>c__DisplayClass3_1.<UseSerilog>b__1(IServiceProvider services)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitFactory(FactoryCallSite factoryCallSite, RuntimeResolverContext context)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor`2.VisitCallSiteMain(ServiceCallSite callSite, TArgument argument)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitCache(ServiceCallSite callSite, RuntimeResolverContext context, ServiceProviderEngineScope serviceProviderEngine, RuntimeResolverLock lockType)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitRootCache(ServiceCallSite singletonCallSite, RuntimeResolverContext context)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor`2.VisitCallSite(ServiceCallSite callSite, TArgument argument)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.Resolve(ServiceCallSite callSite, ServiceProviderEngineScope scope)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.DynamicServiceProviderEngine.<>c__DisplayClass1_0.<RealizeService>b__0(ServiceProviderEngineScope scope)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.ServiceProviderEngine.GetService(Type serviceType, ServiceProviderEngineScope serviceProviderEngineScope)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.ServiceProviderEngineScope.GetService(Type serviceType)
   at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService(IServiceProvider provider, Type serviceType)
   at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService[T](IServiceProvider provider)
   at Serilog.SerilogHostBuilderExtensions.<>c__DisplayClass3_1.<UseSerilog>b__3(IServiceProvider services)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitFactory(FactoryCallSite factoryCallSite, RuntimeResolverContext context)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor`2.VisitCallSiteMain(ServiceCallSite callSite, TArgument argument)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitCache(ServiceCallSite callSite, RuntimeResolverContext context, ServiceProviderEngineScope serviceProviderEngine, RuntimeResolverLock lockType)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitRootCache(ServiceCallSite singletonCallSite, RuntimeResolverContext context)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor`2.VisitCallSite(ServiceCallSite callSite, TArgument argument)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitConstructor(ConstructorCallSite constructorCallSite, RuntimeResolverContext context)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor`2.VisitCallSiteMain(ServiceCallSite callSite, TArgument argument)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitCache(ServiceCallSite callSite, RuntimeResolverContext context, ServiceProviderEngineScope serviceProviderEngine, RuntimeResolverLock lockType)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitRootCache(ServiceCallSite singletonCallSite, RuntimeResolverContext context)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor`2.VisitCallSite(ServiceCallSite callSite, TArgument argument)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitConstructor(ConstructorCallSite constructorCallSite, RuntimeResolverContext context)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor`2.VisitCallSiteMain(ServiceCallSite callSite, TArgument argument)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitCache(ServiceCallSite callSite, RuntimeResolverContext context, ServiceProviderEngineScope serviceProviderEngine, RuntimeResolverLock lockType)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitRootCache(ServiceCallSite singletonCallSite, RuntimeResolverContext context)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor`2.VisitCallSite(ServiceCallSite callSite, TArgument argument)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitConstructor(ConstructorCallSite constructorCallSite, RuntimeResolverContext context)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor`2.VisitCallSiteMain(ServiceCallSite callSite, TArgument argument)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitCache(ServiceCallSite callSite, RuntimeResolverContext context, ServiceProviderEngineScope serviceProviderEngine, RuntimeResolverLock lockType)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.VisitRootCache(ServiceCallSite singletonCallSite, RuntimeResolverContext context)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor`2.VisitCallSite(ServiceCallSite callSite, TArgument argument)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.Resolve(ServiceCallSite callSite, ServiceProviderEngineScope scope)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.DynamicServiceProviderEngine.<>c__DisplayClass1_0.<RealizeService>b__0(ServiceProviderEngineScope scope)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.ServiceProviderEngine.GetService(Type serviceType, ServiceProviderEngineScope serviceProviderEngineScope)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.ServiceProviderEngine.GetService(Type serviceType)
   at Microsoft.Extensions.DependencyInjection.ServiceProvider.GetService(Type serviceType)
   at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService(IServiceProvider provider, Type serviceType)
   at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService[T](IServiceProvider provider)
   at Microsoft.Extensions.Hosting.HostBuilder.Build()
   at SMApply.CLI.Program.Main(String[] args) in /src/repos/SMApply/SMApply.CLI.WTF/Program.cs:line 40
2021-05-14 07:43:13.715 -07:00 [INFO] Closing and flushing logs {}

Not one mention in this error of Scoped services or of Worker or of Singleton. Instead it quite clearly states the issue. It can't load Serilog.Sinks.Slack. Well if you had just told me that 3 hours ago I would have gladly removed the reference and moved on with life!

Just to ensure I don't get too confident, I am now getting an "Invalid XHTML" parsing error while trying to save and publish this post. Now I get to remove each line one at a time until I can figure out why it isn't properly formatted. :)

Do you have a similar story of a seemingly innocent and simple piece of code that you just can't seem to get working? If you don't then you having done much software development

There was some discussion recently about how to name a server. Some common practices in the past for naming servers were to use a theme. So you might use the names of planets or cities or some other witty theme.

The problem with themes is that once you have hundreds or thousands of machines to name you begin to run into challenges with remembering which names you have already used or you just run out of planets to use.

So how can you avoid the problems of using a theme for a naming convention and still get a useful name. The bad news is that there is no perfect solution to this problem. You could use some random name generator, but that is that helpful. It avoids the problem of having to come up with a name yourself and it also avoids the problem of running out of ideas. Perhaps naming a server mlcrkkyz by creating a random string works for you. For most admins this would be a nightmare. What is that server even use for?

With the ever increasing popularity of cloud based servers a convention of including location information in the host name has been sued in the host name.  Including a role for the server and a service level is also helpful.  Adding an indexer or sequential ID is helpful to distinguish servers that may otherwise generate the same name.

If we use this as our naming convention we might get hostnames that look like the following.

• USCA153DBP001
• EUITRWST002

So the first server name would indicate that it is located in the United States and in California.  The 153 building number other local identifer.  DB indicates that the role of the server is a database and the P indicates that it is a production server.  The 001 is just an indexer to avoid name conflicts with similar hostnames.

In the second example we can see that the server is located in the European Union and in Italy.  The R is a local identifer.  WS indicates that this is a web server and the T indicates that it is in a test environment.  Finally the 002 is just a sequential identifier.

Using a naming convention like this is great because it is scalable, easy to identify the location of the server, the role of the server and the type of environment the server is use for.  Some downsides to using this is that if you only have a single location for servers then there is a lot of redundancy in the names and using location information in the name doesn't really add much useful information.  If you do change the location of a server then the name will have to change.  This can provide quite a few challenges and is generally frowned upon.  The length of names for such hostnames can also be an issue for some tools.

If that naming convention works for your situation then great.  Here are some variations on that concept.  In the not to distant pass servers were located on premise and you had full control over them.  These days it is not uncommon to have servers that are in the cloud.  Often you have a hybrid environment were some servers are in the cloud and some are located on premise.  Perhaps a location identifier that identifies the provider as cloud or on premise would be useful.  If you use multiple cloud providers then you can indicate which provider it is with.

If you do not have multiple locations then perhaps a department or customer identifier would be more appropriate.  If you have a mix of platforms then you may want to use software or service identifier.

Here is a alternative suggested format for names. 

• Location of server

  • (L)OP - Local On Premise
  • GC(P) - Google Cloud Platform
  • (M)AZ - Microsoft Azure
  • AW(S) - Amazon Web Services

• Software/OS Identifier

  • WIN - Windows
  • NIX - Unix variant
  • CentOs - Centos
  • Ubuntu - Ubuntu

• Software Version

  • 2019
  • 8
  • 20

• Department

  • RD - Research and Development
  • AM - Advertising and Marketing
  • CM - Communications
  • IT - Information Technology

• Device Role

  • DB - Database
  • DC - Domain Controller
  • AS - App Server
  • SW - Switch
  • WS - Web server

• Service Level

  • P - Production
  • T - Test
  • D - Development
  • S - Staging

• Sequential Identifier

  • 001

Using all or a subset of the above might result in hostnames similar the the following.

• OPWINITWSD001
• MNIXRDASP005
• MWINIT-WS-S001
• WIN-IT-DC-OP-T-001

You can add dashes to help with the human readability of the server and put the identifiers in whatever order makes since for your organization.

I hope this gives you a place to start when thinking about how you can name your devices.