Add Metrics

src/Elastic.Apm.AspNetCore/Config/MicrosoftExtensionsConfig.cs

@@ -23,6 +23,7 @@ internal static class Keys
 			internal const string SecretToken = "ElasticApm:SecretToken";
 			internal const string CaptureHeaders = "ElasticApm:CaptureHeaders";
 			internal const string TransactionSampleRate = "ElasticApm:TransactionSampleRate";
+			internal const string MetricsInterval = "ElasticApm:MetricsInterval";
 		}
 
 		private readonly IConfiguration _configuration;
@@ -60,6 +61,8 @@ public LogLevel LogLevel
 
 		public double TransactionSampleRate => ParseTransactionSampleRate(ReadFallBack(Keys.TransactionSampleRate, ConfigConsts.EnvVarNames.TransactionSampleRate));
 
+		public double MetricsIntervalInMillisecond  => ParseMetricsInterval(ReadFallBack(Keys.MetricsInterval , ConfigConsts.EnvVarNames.MetricsInterval));
+
 		private ConfigurationKeyValue Read(string key) => Kv(key, _configuration[key], Origin);
 
 		private ConfigurationKeyValue ReadFallBack(string key, string fallBackEnvVarName)

src/Elastic.Apm/Agent.cs

@@ -4,7 +4,6 @@
 using Elastic.Apm.Config;
 using Elastic.Apm.DiagnosticSource;
 using Elastic.Apm.Logging;
-using Elastic.Apm.Model;
 using Elastic.Apm.Report;
 
 //TODO: It'd be nice to move this into the .csproj
@@ -106,7 +105,6 @@ public static class Agent
 		public static void Setup(AgentComponents agentComponents)
 		{
 			if (Lazy.IsValueCreated) throw new Exception("The singleton APM agent has already been instantiated and can no longer be configured");
-
 			_components = agentComponents;
 		}
 	}

src/Elastic.Apm/AgentComponents.cs

@@ -2,7 +2,7 @@
 using Elastic.Apm.Api;
 using Elastic.Apm.Config;
 using Elastic.Apm.Logging;
-using Elastic.Apm.Model;
+using Elastic.Apm.Metrics;
 using Elastic.Apm.Report;
 
 namespace Elastic.Apm
@@ -15,23 +15,34 @@ public AgentComponents(
 			IPayloadSender payloadSender = null
 		)
 		{
-
 			Logger = logger ?? ConsoleLogger.LoggerOrDefault(configurationReader?.LogLevel);
 			ConfigurationReader = configurationReader ?? new EnvironmentConfigurationReader(Logger);
+			Service = Service.GetDefaultService(ConfigurationReader);
+			PayloadSender = payloadSender ?? new PayloadSenderV2(Logger, ConfigurationReader, Service);
 
-			Service =  Service.GetDefaultService(ConfigurationReader);
+			MetricsCollector = new MetricsCollector(Logger, PayloadSender, ConfigurationReader);
+			MetricsCollector.StartCollecting();
 
-			PayloadSender = payloadSender ?? new PayloadSenderV2(Logger, ConfigurationReader, Service);
 			TracerInternal = new Tracer(Logger, Service, PayloadSender, ConfigurationReader);
 			TransactionContainer = new TransactionContainer();
 		}
 
+		internal AgentComponents(
+			IMetricsCollector metricsCollector,
+			IApmLogger logger = null,
+			IConfigurationReader configurationReader = null,
+			IPayloadSender payloadSender = null
+		) : this(logger, configurationReader, payloadSender)
+			=> (MetricsCollector = metricsCollector ?? new MetricsCollector(Logger, PayloadSender, ConfigurationReader)).StartCollecting();
+
 		public IConfigurationReader ConfigurationReader { get; }
 
 		public IApmLogger Logger { get; }
 
 		public IPayloadSender PayloadSender { get; }
 
+		private IMetricsCollector MetricsCollector { get; }
+
 		/// <summary>
 		/// Identifies the monitored service. If this remains unset the agent
 		/// automatically populates it based on the entry assembly.
@@ -47,9 +58,14 @@ public AgentComponents(
 
 		public void Dispose()
 		{
-			if (PayloadSender is IDisposable disposable)
+			if (MetricsCollector is IDisposable disposableMetricsCollector)
+			{
+				disposableMetricsCollector.Dispose();
+			}
+
+			if (PayloadSender is IDisposable disposablePayloadSender)
 			{
-				disposable?.Dispose();
+				disposablePayloadSender.Dispose();
 			}
 		}
 	}

src/Elastic.Apm/Api/IMetricSet.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+
+namespace Elastic.Apm.Api
+{
+	/// <summary>
+	/// Data captured by the agent representing a metric occurring in a monitored service
+	/// </summary>
+	public interface IMetricSet
+	{
+		/// <summary>
+		/// List of captured metrics as key - value pairs
+		/// </summary>
+		IEnumerable<MetricSample> Samples { get; set; }
+
+		/// <summary>
+		/// Number of milliseconds in unix time
+		/// </summary>
+		long TimeStamp { get; set; }
+	}
+}

src/Elastic.Apm/Api/MetricSample.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Elastic.Apm.Helpers;
+
+namespace Elastic.Apm.Api
+{
+	/// <summary>
+	/// A single metric sample.
+	/// </summary>
+	public class MetricSample
+	{
+		public MetricSample(string key, double value)
+			=> KeyValue = new KeyValuePair<string, double>(key, value);
+
+		internal KeyValuePair<string, double> KeyValue { get; set; }
+
+		public override string ToString() => new ToStringBuilder(nameof(MetricSample)) { { KeyValue.Key, KeyValue.Value }, }.ToString();
+	}
+}

src/Elastic.Apm/Config/AbstractConfigurationReader.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
+using System.Linq;
 using System.Reflection;
 using Elastic.Apm.Logging;
 
@@ -111,6 +112,85 @@ bool TryParseUri(string u, out Uri uri)
 			}
 		}
 
+		protected double ParseMetricsInterval(ConfigurationKeyValue kv)
+		{
+			string value;
+			if (kv == null || string.IsNullOrWhiteSpace(kv.Value))
+				value = ConfigConsts.DefaultValues.MetricsInterval;
+			else
+				value = kv.Value;
+
+			if (!TryParseTimeInterval(value, out var valueInMilliseconds))
+			{
+				Logger?.Error()
+					?.Log("Failed to parse provided metrics interval `{ProvidedMetricsInterval}' - " +
+						"using default: {DefaultMetricsInterval}",
+						value,
+						ConfigConsts.DefaultValues.MetricsInterval);
+				return ConfigConsts.DefaultValues.MetricsIntervalInMilliseconds;
+			}
+
+			// ReSharper disable once CompareOfFloatsByEqualityOperator - we compare to exactly zero here
+			if (valueInMilliseconds == 0)
+				return valueInMilliseconds;
+
+			if (valueInMilliseconds < 0)
+			{
+				Logger?.Error()
+					?.Log("Provided metrics interval `{ProvidedMetricsInterval}' is negative - " +
+						"metrics collection will be disabled",
+						value);
+				return 0;
+			}
+
+			if (valueInMilliseconds < ConfigConsts.Constraints.MinMetricsIntervalInMillisecond)
+			{
+				Logger?.Error()
+					?.Log("Provided metrics interval `{ProvidedMetricsInterval}' is smaller than allowed minimum: {MinProvidedMetricsInterval}ms - " +
+						"metrics collection will be disabled",
+						value,
+						ConfigConsts.Constraints.MinMetricsIntervalInMillisecond);
+				return 0;
+			}
+
+			return valueInMilliseconds;
+		}
+
+		private bool TryParseTimeInterval(String valueAsString, out double valueInMilliseconds)
+		{
+			switch (valueAsString)
+			{
+				case string _ when valueAsString.Length >= 2 && valueAsString.Substring(valueAsString.Length - 2).ToLower() == "ms":
+					return TryParseFloatingPoint(valueAsString.Substring(0, valueAsString.Length - 2), out valueInMilliseconds);
+
+				case string _ when char.ToLower(valueAsString.Last()) == 's':
+					if (!TryParseFloatingPoint(valueAsString.Substring(0, valueAsString.Length - 1), out var valueInSeconds))
+					{
+						valueInMilliseconds = 0;
+						return false;
+					}
+					valueInMilliseconds = TimeSpan.FromSeconds(valueInSeconds).TotalMilliseconds;
+					return true;
+
+				case string _ when char.ToLower(valueAsString.Last()) == 'm':
+					if (!TryParseFloatingPoint(valueAsString.Substring(0, valueAsString.Length - 1), out var valueInMinutes))
+					{
+						valueInMilliseconds = 0;
+						return false;
+					}
+					valueInMilliseconds = TimeSpan.FromMinutes(valueInMinutes).TotalMilliseconds;
+					return true;
+				default:
+					if (!TryParseFloatingPoint(valueAsString, out var valueInSecondsNoUnits))
+					{
+						valueInMilliseconds = 0;
+						return false;
+					}
+					valueInMilliseconds = TimeSpan.FromSeconds(valueInSecondsNoUnits).TotalMilliseconds;
+					return true;
+			}
+		}
+
 		protected virtual string DiscoverServiceName()
 		{
 			var entryAssemblyName = Assembly.GetEntryAssembly()?.GetName();

src/Elastic.Apm/Config/ConfigConsts.cs

@@ -12,12 +12,20 @@ public static class EnvVarNames
 			public const string SecretToken = "ELASTIC_APM_SECRET_TOKEN";
 			public const string CaptureHeaders = "ELASTIC_APM_CAPTURE_HEADERS";
 			public const string TransactionSampleRate = "ELASTIC_APM_TRANSACTION_SAMPLE_RATE";
+			public const string MetricsInterval = "ELASTIC_APM_METRICS_INTERVAL";
 		}
 
 		public static class DefaultValues
 		{
 			public const double TransactionSampleRate = 1.0;
 			public const string UnknownServiceName = "unknown";
+			public const double MetricsIntervalInMilliseconds = 30 * 1000;
+			public const string MetricsInterval = "30s";
+		}
+
+		public static class Constraints
+		{
+			public const double MinMetricsIntervalInMillisecond = 1000;
 		}
 
 		public static Uri DefaultServerUri => new Uri("http://localhost:8200");

src/Elastic.Apm/Config/EnvironmentConfigurationReader.cs

@@ -22,6 +22,8 @@ public EnvironmentConfigurationReader(IApmLogger logger = null) : base(logger) {
 
 		public double TransactionSampleRate => ParseTransactionSampleRate(Read(ConfigConsts.EnvVarNames.TransactionSampleRate));
 
+		public double MetricsIntervalInMillisecond => ParseMetricsInterval(Read(ConfigConsts.EnvVarNames.MetricsInterval));
+
 		private static ConfigurationKeyValue Read(string key) =>
 			new ConfigurationKeyValue(key, Environment.GetEnvironmentVariable(key), Origin);
 	}

src/Elastic.Apm/Config/IAgentConfigReader.cs

@@ -12,5 +12,6 @@ public interface IConfigurationReader
 		string SecretToken { get; }
 		bool CaptureHeaders { get; }
 		double TransactionSampleRate { get; }
+		double MetricsIntervalInMillisecond { get; }
 	}
 }

src/Elastic.Apm/Elastic.Apm.csproj

@@ -25,6 +25,7 @@
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
     <!-- TODO: Are we ok with this reference/version? -->
     <PackageReference Include="System.Diagnostics.DiagnosticSource" Version="4.0.0" />
+    <PackageReference Include="System.Diagnostics.PerformanceCounter" Version="4.5.0" />
     <PackageReference Include="System.Threading.Tasks.Dataflow" Version="4.9.0" />
   </ItemGroup>
 </Project>

src/Elastic.Apm/Logging/IApmLoggingExtensions.cs

@@ -91,7 +91,7 @@ internal readonly struct MaybeLogger
 			public void Log(string message, params object[] args) => _logger.DoLog(_level, message, null, args);
 
 			public void LogException(Exception exception, string message, params object[] args) =>
-				_logger.DoLog(_level, message, exception, args, exception.GetType().FullName, exception.Message);
+				_logger.DoLog(_level, message, exception, args);
 
 			public void LogExceptionWithCaller(Exception exception,
 				[CallerMemberName] string method = "",

src/Elastic.Apm/Metrics/IMetricsCollector.cs

@@ -0,0 +1,13 @@
+namespace Elastic.Apm.Metrics
+{
+	/// <summary>
+	/// Defines how the agent collects metrics.
+	/// </summary>
+	internal interface IMetricsCollector
+	{
+		/// <summary>
+		/// After calling this method, the <see cref="IMetricsCollector"/> starts collecting metrics
+		/// </summary>
+		void StartCollecting();
+	}
+}

src/Elastic.Apm/Metrics/IMetricsProvider.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using Elastic.Apm.Api;
+
+namespace Elastic.Apm.Metrics
+{
+	/// <summary>
+	/// Defines an interface that every class, which provides some metric value, should implement.
+	/// This interface is known to the <see cref="MetricsCollector" /> type and you
+	/// can implement new providers for other metrics by implementing this interface
+	/// and adding it to <see cref="MetricsCollector" />.
+	/// </summary>
+	internal interface IMetricsProvider
+	{
+		/// <summary>
+		/// Stores the number of calls to the <see cref="GetSamples"/> method when it either returned null or an empty list.
+		/// This is used by <see cref="MetricsCollector"/>
+		/// </summary>
+		int ConsecutiveNumberOfFailedReads { get; set; }
+
+		/// <summary>
+		/// The name that refers to the provider in the logs. E.g. "total process CPU time".
+		/// Make sure this is human understandable and tells the reader what type of value this provider is intended to provide.
+		/// </summary>
+		string DbgName { get; }
+
+		/// <summary>
+		/// The main part of the provider, the implementor should do the work to read the value(s) of the given metric(s) in this method.
+		/// </summary>
+		/// <returns>The key and the value of the metric(s)</returns>
+		IEnumerable<MetricSample> GetSamples();
+	}
+}

src/Elastic.Apm/Metrics/MetricSet.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using Elastic.Apm.Api;
+using Elastic.Apm.Report.Serialization;
+using Newtonsoft.Json;
+
+namespace Elastic.Apm.Metrics
+{
+	[JsonConverter(typeof(MetricSetConverter))]
+	internal class MetricSet : IMetricSet
+	{
+		public MetricSet(long timeStamp, List<MetricSample> samples)
+			=> (TimeStamp, Samples) = (timeStamp, samples);
+
+		public IEnumerable<MetricSample> Samples { get; set; }
+
+		[JsonProperty("timestamp")]
+		public long TimeStamp { get; set; }
+	}
+}