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)); }