protected override async Task Handle(MetricRequest <NetworkSpeedWidget> request, CancellationToken cancellationToken)
{
if (!NetworkInterface.GetIsNetworkAvailable())
{
throw new Exception("Network is not available.");
}
var networkInterface = NetworkInterface.GetAllNetworkInterfaces().FirstOrDefault(k => k.Id == request.Context.NetworkInterfaceId);
if (networkInterface is null)
{
throw new Exception($"Network interface '{request.Context.NetworkInterfaceId}' could not be found.");
}
var startValue = networkInterface.GetIPv4Statistics();
var starTime = DateTime.Now;
await Task.Delay(1000).ConfigureAwait(false);
var endValue = networkInterface.GetIPv4Statistics();
var endTime = DateTime.Now;
var totalBytes = request.Context.Direction == NetworkSpeedDirection.Upload ?
endValue.BytesSent - startValue.BytesSent :
endValue.BytesReceived - startValue.BytesReceived;
request.Context.Value = totalBytes / (endTime - starTime).TotalSeconds;
request.Context.Status = Status.OK;
}
protected override void Handle(MetricRequest <T> request, Exception exception, RequestExceptionHandlerState <Unit> state)
{
request.Context.Status = Status.Error;
_dispatcher.Invoke(() => request.Context.Clear());
state.SetHandled();
}
protected override async Task Handle(MetricRequest <NuGetPackageDownloadsWidget> request, CancellationToken cancellationToken)
{
var api = new NuGetApi(Endpoint.Address);
var packageMetadata = await api.GetPackageMetadataAsync(request.Context.PackageId, request.Context.PreRelease, cancellationToken).ConfigureAwait(false);
request.Context.Value = packageMetadata.TotalDownloads;
request.Context.Status = Status.OK;
}
protected override void Handle(MetricRequest <ThreadCountWidget> request)
{
using (var counter = string.IsNullOrWhiteSpace(request.Context.MachineName)
? new System.Diagnostics.PerformanceCounter(CategoryName, CounterName)
: new System.Diagnostics.PerformanceCounter(CategoryName, CounterName, InstanceName, request.Context.MachineName))
{
request.Context.Value = (int)counter.NextValue();
request.Context.Status = Status.OK;
}
}
/// <summary>
/// Creates a single metric.
/// </summary>
/// <param name="key">States what the metric represents, such as a player action or other occurrence. You may want to create your keys in groups, e.g. "player:jump".</param>
/// <param name="subject">Identifies the subject this metric is for. This would commonly be a unique user identifier.</param>
/// <param name="value">Value of this metric.</param>
/// <returns></returns>
public Task <MetricResponse> Create(Metric metric)
{
if (metric == null)
{
throw new ArgumentNullException(nameof(metric));
}
var request = new MetricRequest(metric);
return(this.m_httpClient.Post <MetricResponse>(request, ENDPOINT + "/" + metric.Subject.UrlEncode()));
}
protected override async Task Handle(MetricRequest <CpuUsageWidget> request, CancellationToken cancellationToken)
{
using var counter = new System.Diagnostics.PerformanceCounter(CategoryName, CounterName, InstanceName);
counter.NextValue();
await Task.Delay(500, cancellationToken).ConfigureAwait(false);
request.Context.Value = Math.Round(counter.NextValue());
request.Context.Status = Status.OK;
}
protected override void Handle(MetricRequest <PerformanceCounterWidget> request)
{
var widget = request.Context;
using var counter = string.IsNullOrWhiteSpace(widget.MachineName)
? new System.Diagnostics.PerformanceCounter(widget.CategoryName, widget.CounterName, widget.InstanceName)
: new System.Diagnostics.PerformanceCounter(widget.CategoryName, widget.CounterName, widget.InstanceName, widget.MachineName);
widget.Value = (int)counter.NextValue();
widget.Status = Status.OK;
}
public MetricsResponseDTO GetSingleMetric(MetricRequest request)
{
var result = _MetricRepository.GetSingleMetric(request.CompanyName, request.Username, request.Endpoint, request.After, request.Before);
return(new MetricsResponseDTO
{
Key = result.Key,
NumberOfRequests = result.NumberOfRequests,
MinResponseTime = result.MinResponseTime,
AverageResponseTime = result.AverageResponseTime,
MaxResponseTime = result.MaxResponseTime
});
}
protected async override Task Handle(MetricRequest <AzureDevOpsPullRequestsWidget> request, CancellationToken cancellationToken)
{
var api = new AzureDevOpsApi(Endpoint);
var pullRequests = await api.GetPullRequestsAsync(request.Context.Account, request.Context.Project).ConfigureAwait(false);
request.Context.Value = pullRequests.Count;
if (pullRequests is null || pullRequests.Count == 0)
{
request.Context.Status = Status.None;
_dispatcher.InvokeAsync(request.Context.Clear);
}
public MetricsResponseDTO[] GetEndpointMetrics(MetricRequest request)
{
var result = _MetricRepository.GetEndpointMetrics(request.CompanyName, request.Username, request.Size, request.Ascending, request.After, request.Before);
return((from r in result
select new MetricsResponseDTO
{
Key = r.Key,
NumberOfRequests = r.NumberOfRequests,
MinResponseTime = r.MinResponseTime,
AverageResponseTime = r.AverageResponseTime,
MaxResponseTime = r.MaxResponseTime
}).ToArray());
}
internal static HttpContent GetHttpContent(HoundMetricCollection houndMetricCollection, string prefix)
{
var metricRequest = new MetricRequest
{
Series = new List <MetricSeries>
{
new MetricSeries
{
Host = houndMetricCollection.Host,
Title = $"{prefix}.{houndMetricCollection.Title.ToLowerInvariant().Replace(' ', '.')}",
Points = houndMetricCollection.Points.Select(p => new List <decimal> {
GetPosixDateTime(p.Timestamp), p.Value
} as IEnumerable <decimal>)
}
}
};
HttpContent content = new StringContent(JsonConvert.SerializeObject(metricRequest));
content.Headers.Remove("Content-type");
content.Headers.Add("Content-type", "application/json");
return(content);
}
protected override Task Handle(MetricRequest <DemoMetricWidget> request, CancellationToken cancellationToken)
{
double value;
string status;
if (request.Context.Randomize)
{
var rnd = new Random();
value = rnd.Next(0, 100);
Status.TryParse(rnd.Next(0, 14), out status);
}
else
{
value = 1;
status = Status.OK;
}
request.Context.Value = value;
request.Context.Status = status;
return(Unit.Task);
}
public void GetEndpointMetrics_HappyPath()
{
var request = new MetricRequest
{
After = _After,
Before = _Before,
CompanyName = _CompanyName,
Username = _Username,
Size = _Size,
Ascending = _Ascending
};
var entity = new MetricsResponse[]
{
new MetricsResponse {
Key = _Endpoint,
NumberOfRequests = _ResponseTime,
MinResponseTime = _ResponseTime,
AverageResponseTime = _ResponseTime,
MaxResponseTime = _ResponseTime
}
};
var mockRepository = Substitute.For <IMetricRepository>();
mockRepository.GetEndpointMetrics(_CompanyName, _Username, _Size, _Ascending, _After, _Before).Returns(entity);
var engine = new MetricEngine(mockRepository);
var response = engine.GetEndpointMetrics(request);
Assert.AreEqual(entity[0].Key, response[0].Key);
Assert.AreEqual(entity[0].NumberOfRequests, response[0].NumberOfRequests);
Assert.AreEqual(entity[0].MinResponseTime, response[0].MinResponseTime);
Assert.AreEqual(entity[0].AverageResponseTime, response[0].AverageResponseTime);
Assert.AreEqual(entity[0].MaxResponseTime, response[0].MaxResponseTime);
}
protected override void Handle(MetricRequest <ActiveTcpConnectionsWidget> request)
{
request.Context.Value = IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpConnections().Length;
request.Context.Status = Status.OK;
}
protected override async Task Handle(MetricRequest <ProcessCpuUsageWidget> request, CancellationToken cancellationToken)
{
request.Context.Value = await GetCpuUsageAsync(request.Context.MachineName, request.Context.ProcessName).ConfigureAwait(false);
request.Context.Status = Status.OK;
}
protected override void Handle(MetricRequest <RamUsageWidget> request)
{
request.Context.Value = (int)RamInformation.GetPercentageOfMemoryInUseMiB();
request.Context.Status = Status.OK;
}
public MetricsResponseDTO[] GetEndpointMetrics(MetricRequest request)
{
return(_MetricEngine.GetEndpointMetrics(request));
}
protected override void Handle(MetricRequest <BatteryWidget> request)
{
request.Context.Value = (int)(_powerStatus.BatteryLifePercent * 100);
//request.DataContext.Message = $"{power.BatteryLifeRemaining / 3600} hr {power.BatteryLifeRemaining % 3600 / 60} min remaining";
request.Context.Status = _powerStatus.BatteryLifePercent * 100 >= request.Context.BatteryLifePercentThreshold ? Status.OK : Status.Failed;
}
public MetricsResponseDTO GetSingleMetric(MetricRequest request)
{
return(_MetricEngine.GetSingleMetric(request));
}
public MetricsResponseDTO[] GetCompanyMetrics(MetricRequest request)
{
return(_MetricEngine.GetCompanyMetrics(request));
}
