public Task <ActionResult> Trace( int?pid, [FromQuery] TraceProfile profile = DefaultTraceProfiles, [FromQuery][Range(-1, int.MaxValue)] int durationSeconds = 30, [FromQuery][Range(1, int.MaxValue)] int metricsIntervalSeconds = 1) { TimeSpan duration = ConvertSecondsToTimeSpan(durationSeconds); return(this.InvokeService(async() => { var configurations = new List <MonitoringSourceConfiguration>(); if (profile.HasFlag(TraceProfile.Cpu)) { configurations.Add(new CpuProfileConfiguration()); } if (profile.HasFlag(TraceProfile.Http)) { configurations.Add(new HttpRequestSourceConfiguration()); } if (profile.HasFlag(TraceProfile.Logs)) { configurations.Add(new LoggingSourceConfiguration()); } if (profile.HasFlag(TraceProfile.Metrics)) { configurations.Add(new MetricSourceConfiguration(metricsIntervalSeconds)); } var aggregateConfiguration = new AggregateSourceConfiguration(configurations.ToArray()); return await StartTrace(pid, aggregateConfiguration, duration); })); }
private void VerifyEqual(TraceProfile expected, TraceProfileDescriptor actual) { Assert.Equal(expected.Collectors.Count, actual.Collectors.Count); for (int i = 0; i < expected.Collectors.Count; ++i) { VerifyEqual((dynamic)expected.Collectors[i], (dynamic)actual.Collectors[i]); } }
protected override async Task <CollectionRuleActionResult> ExecuteCoreAsync( TaskCompletionSource <object> startCompletionSource, CancellationToken token) { TimeSpan duration = Options.Duration.GetValueOrDefault(TimeSpan.Parse(CollectTraceOptionsDefaults.Duration)); string egressProvider = Options.Egress; MonitoringSourceConfiguration configuration; if (Options.Profile.HasValue) { TraceProfile profile = Options.Profile.Value; float metricsIntervalSeconds = _counterOptions.CurrentValue.GetIntervalSeconds(); configuration = TraceUtilities.GetTraceConfiguration(profile, metricsIntervalSeconds); } else { EventPipeProvider[] optionsProviders = Options.Providers.ToArray(); bool requestRundown = Options.RequestRundown.GetValueOrDefault(CollectTraceOptionsDefaults.RequestRundown); int bufferSizeMegabytes = Options.BufferSizeMegabytes.GetValueOrDefault(CollectTraceOptionsDefaults.BufferSizeMegabytes); configuration = TraceUtilities.GetTraceConfiguration(optionsProviders, requestRundown, bufferSizeMegabytes); } string fileName = TraceUtilities.GenerateTraceFileName(EndpointInfo); KeyValueLogScope scope = Utils.CreateArtifactScope(Utils.ArtifactType_Trace, EndpointInfo); EgressOperation egressOperation = new EgressOperation( async(outputStream, token) => { using IDisposable operationRegistration = _operationTrackerService.Register(EndpointInfo); await TraceUtilities.CaptureTraceAsync(startCompletionSource, EndpointInfo, configuration, duration, outputStream, token); }, egressProvider, fileName, EndpointInfo, ContentTypes.ApplicationOctetStream, scope); ExecutionResult <EgressResult> result = await egressOperation.ExecuteAsync(_serviceProvider, token); string traceFilePath = result.Result.Value; return(new CollectionRuleActionResult() { OutputValues = new Dictionary <string, string>(StringComparer.Ordinal) { { CollectionRuleActionConstants.EgressPathOutputValueName, traceFilePath } } }); }
public static TraceProfileDescriptor GetDescriptor(this TraceProfile activeProfile) { var d = new TraceProfileDescriptor(); foreach (var collector in activeProfile.Collectors) { if (collector is EventCollector ec) { d.Collectors.Add(GetDescriptor(ec)); } } return(d); }
public Task <ActionResult> Trace( int?pid, [FromQuery] TraceProfile profile = DefaultTraceProfiles, [FromQuery][Range(-1, int.MaxValue)] int durationSeconds = 30, [FromQuery][Range(1, int.MaxValue)] int metricsIntervalSeconds = 1) { TimeSpan duration = ConvertSecondsToTimeSpan(durationSeconds); return(InvokeService(async() => { int pidValue = _diagnosticServices.ResolveProcess(pid); IStreamWithCleanup result = await _diagnosticServices.StartTrace(pidValue, profile, duration, metricsIntervalSeconds, this.HttpContext.RequestAborted); return new StreamWithCleanupResult(result, "application/octet-stream", FormattableString.Invariant($"{Guid.NewGuid()}.nettrace")); })); }
public async Task CollectTraceAction_ProfileSuccess(TargetFrameworkMoniker tfm, TraceProfile traceProfile) { using TemporaryDirectory tempDirectory = new(_outputHelper); await TestHostHelper.CreateCollectionRulesHost(_outputHelper, rootOptions => { rootOptions.AddFileSystemEgress(ActionTestsConstants.ExpectedEgressProvider, tempDirectory.FullName); rootOptions.CreateCollectionRule(DefaultRuleName) .AddCollectTraceAction(traceProfile, ActionTestsConstants.ExpectedEgressProvider, options => { options.Duration = TimeSpan.FromSeconds(2); }) .SetStartupTrigger(); }, async host => { await PerformTrace(host, tfm); }); }
public void GetDescriptor_TraceProfile(TraceProfile expected) { var actual = TraceProfileUtils.GetDescriptor(expected); VerifyEqual(expected, actual); }
public static CollectionRuleOptions AddCollectTraceAction(this CollectionRuleOptions options, TraceProfile profile, string egress, Action <CollectTraceOptions> callback = null) { return(options.AddAction( KnownCollectionRuleActions.CollectTrace, actionOptions => { CollectTraceOptions collectTraceOptions = new(); collectTraceOptions.Profile = profile; collectTraceOptions.Egress = egress; callback?.Invoke(collectTraceOptions); actionOptions.Settings = collectTraceOptions; })); }