Revisit the output of Environment.OSVersion.ToString()

[am11]

On Linux, current situation is this:

Ubuntu 18.04 x64
Environment.OSVersion.ToString()	Unix 4.15.0.106
RuntimeInformation.OSDescription	Linux 4.15.0-106-generic #107-Ubuntu SMP Thu Jun 4 11:27:52 UTC 2020

On other (non-macOS) Unix-like OS, it looks like this:

SmartOS 2020 x64
Environment.OSVersion.ToString()	Unix 5.11.0.0
RuntimeInformation.OSDescription	SunOS 5.11 joyent_20200520T174734Z

IMO, Environment.OSVersion.ToString()'s output is not useful, as it does not specify if it is the kernel version, OS/userland version and which (base?) OS it really is.

Assuming that it is unlikely that the consumers are relying on the vague value of Environment.OSVersion.ToString() on Linux: it would be more helpful if this API instead reveals a basic distro/OS information as implemented in this test utility method:

runtime/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.Unix.cs

Line 155 in 579d883

private static DistroInfo GetDistroInfo()

such that the output of above example will looks something like:

Ubuntu 18.04

OS: Ubuntu 18.04, Kernel: Linux 4.15.0.106, Family: Unix

SmartOS 2020

OS: SmartOS 2020, Kernel: SunOS 5.11, Family: Unix

This can be considered as a best effort to:

• give more richer and meaningful information to anyone using Environment.OSVersion.ToString() (mainly for logging, analytics like scenarios).
• likely also help removing the repeated distro detection logic from SDK repo: https://github.com/dotnet/sdk/blob/d95869a/src/Cli/Microsoft.DotNet.Cli.Utils/RuntimeEnvironment.cs#L100.

cc @eerhardt

[eerhardt]

See the very long conversation here: #26780.

IMO, the heart of this issue is "On Linux distros, what is the OS?" Is it the Linux kernel? Is it the distro?

System.OperatingSystem only has a single System.Version that it can include in its .ToString():

runtime/src/libraries/System.Private.CoreLib/src/System/OperatingSystem.cs

Lines 51 to 79 in bd6cbe3

	public override string ToString() => VersionString;
	public string VersionString
	{
	get
	{
	if (_versionString == null)
	{
	string os;
	switch (_platform)
	{
	case PlatformID.Win32S: os = "Microsoft Win32S "; break;
	case PlatformID.Win32Windows: os = (_version.Major > 4 || (_version.Major == 4 && _version.Minor > 0)) ? "Microsoft Windows 98 " : "Microsoft Windows 95 "; break;
	case PlatformID.Win32NT: os = "Microsoft Windows NT "; break;
	case PlatformID.WinCE: os = "Microsoft Windows CE "; break;
	case PlatformID.Unix: os = "Unix "; break;
	case PlatformID.Xbox: os = "Xbox "; break;
	case PlatformID.MacOSX: os = "Mac OS X "; break;
	default:
	Debug.Fail($"Unknown platform {_platform}");
	os = "<unknown> "; break;
	}
	_versionString = string.IsNullOrEmpty(_servicePack) ?
	os + _version.ToString() :
	os + _version.ToString(3) + " " + _servicePack;
	}
	return _versionString;

That is why we have RuntimeInformation.OSDescription. It can provide more than one version, if it wants. But Environment.OSVersion only has a single version.

My recommendation is that if you are on Windows or macOS, you can use Environment.OSVersion and it returns a reasonable result, because those systems have a reasonable single version. If you are on Linux, the best approach is to read and parse the /etc/os-release file if you want distro id and version. (If someone wants to build a library that does that, so the code doesn't need to be copied everywhere, that would be great.) On other non-Linux Unix systems, like SunOS above, if there is a reasonable single version that Environment.OSVersion can return, then we should make it return that. But if there are multiple versions, it probably makes sense to follow what Linux does today and return the version returned from uname.

[am11]

Thanks for the write up.

"On Linux distros, what is the OS?" Is it the Linux kernel? Is it the distro?

These are good questions and I understand that they are non-trivial to address. It is probably better that either we have kernel/base/abstract system name like Linux, SunOS, Darwin; which uname, python, ruby and many tools/platforms use, or the actual OS userland name (Ubuntu, Debian, SmartOS, iOS, macOS). But Unix alone feels too generic from .ToString()'s usage point of view.

That is why we have RuntimeInformation.OSDescription. It can provide more than one version, if it wants.

If we consider this a best-effort API, which provides good enough information about the platform for logging/analytics like scenarios (e.g. dotnet --info), would it make sense that OSDescription also captures (appends) the distro information on Linux? e.g. without introducing a new API, RuntimeInformation.OSDescription will return:

Linux 4.15.0-106-generic #107-Ubuntu SMP Thu Jun 4 11:27:52 UTC 2020 | Ubuntu 18.04
instead of:
Linux 4.15.0-106-generic #107-Ubuntu SMP Thu Jun 4 11:27:52 UTC 2020

if there are multiple versions, it probably makes sense to follow what Linux does today

Yes, it is a similar situation as Linux on SunOS-derivates; kernel and userland have different versions. A slight complication on top is that there is no single contract like /etc/os-release, and each distro uses a different convention.

[eerhardt]

I think adding the distro information to the OSDescription makes sense. Do you want to propose that in an issue?

[am11]

Proposal submitted: #37923.