private DiagnosticResult(string id, string message, DiagnosticSeverity severity, DiagnosticOptions options)
{
Id = id;
Severity = severity;
Message = message;
Options = options;
}
private static AggregateApplicationProcessor CreateApplicationProcessor(ReplicaRegistry replicaRegistry, string[] args, string[] servicesToDebug, Microsoft.Extensions.Logging.ILogger logger, IConfiguration configuration)
{
var diagnosticOptions = DiagnosticOptions.FromConfiguration(configuration);
var diagnosticsCollector = new DiagnosticsCollector(logger, diagnosticOptions);
// Print out what providers were selected and their values
diagnosticOptions.DumpDiagnostics(logger);
var processors = new List <IApplicationProcessor>
{
new EventPipeDiagnosticsRunner(logger, diagnosticsCollector),
new PortAssigner(logger),
new ProxyService(logger),
new HttpProxyService(logger),
new DockerRunner(logger, replicaRegistry),
new ProcessRunner(logger, replicaRegistry, ProcessRunnerOptions.FromArgs(args, servicesToDebug))
};
// If the docker command is specified then transform the ProjectRunInfo into DockerRunInfo
if (args.Contains("--docker"))
{
processors.Insert(0, new TransformProjectsIntoContainers(logger));
}
return(new AggregateApplicationProcessor(processors));
}
protected DiagnosticEventObserver(ILoggerFactory loggerFactory, ITracer tracer, DiagnosticOptions options)
: base(loggerFactory, tracer)
{
_options = options;
if (options.LogEvents)
{
_genericEventProcessor = new GenericEventProcessor(GetListenerName(), Tracer, Logger);
}
}
/// <summary>
/// Transforms the current <see cref="DiagnosticResult"/> to have the specified <see cref="Options"/>.
/// </summary>
/// <param name="options">The options to consider during validation of the expected diagnostic.</param>
/// <returns>A new <see cref="DiagnosticResult"/> copied from the current instance with the specified
/// <paramref name="options"/> applied.</returns>
public DiagnosticResult WithOptions(DiagnosticOptions options)
{
return(new DiagnosticResult(
spans: _spans,
suppressMessage: _suppressMessage,
message: _message,
severity: Severity,
options: options,
id: Id,
messageFormat: MessageFormat,
messageArguments: MessageArguments));
}
public static void EnableDiagnostics(this Workspace workspace, DiagnosticOptions options)
{
var diagnosticProviderOptions = (DiagnosticProvider.Options) 0;
if ((options & DiagnosticOptions.Syntax) != 0)
{
diagnosticProviderOptions |= DiagnosticProvider.Options.Syntax;
}
if ((options & DiagnosticOptions.Semantic) != 0)
{
diagnosticProviderOptions |= DiagnosticProvider.Options.Semantic;
}
DiagnosticProvider.Enable(workspace, diagnosticProviderOptions);
}
public static void AddDiagnostics(this IServiceCollection services, Action <DiagnosticOptions> action = null)
{
DiagnosticOptions diagnosticOptions = new DiagnosticOptions();
action?.Invoke(diagnosticOptions);
services.AddSingleton(diagnosticOptions);
if (diagnosticOptions.IsEnableHostingTracing)
{
services.AddSingleton <IHostingTracingDiagnosticProcessor, HostingTracingDiagnosticProcessor>();
services.AddSingleton <ITracingDiagnosticProcessor, HostingTracingDiagnosticProcessor>();
}
if (diagnosticOptions.IsEnableHttpClientTracing)
{
services.AddSingleton <IHttpClientTracingDiagnosticProcessor, HttpClientTracingDiagnosticProcessor>();
services.AddSingleton <ITracingDiagnosticProcessor, HttpClientTracingDiagnosticProcessor>();
}
services.AddSingleton <IObserver <DiagnosticListener>, TracingDiagnosticObserver>();
services.AddSingleton <TracingDiagnosticObserver>();
services.AddSingleton <ILoggerProvider, DiagnosticLogProvider>();
services.Add(new ServiceDescriptor(typeof(IDiagnosticTraceLogger <>), typeof(DiagnosticTraceLogger <>), ServiceLifetime.Singleton));
//RequestRuleRegister.Register((serviceProvider, request) =>
//{
// if (!(request.Headers.ContainsKey(HttpConstant.TRACEMICROSERVICE) && Regex.Match(request.Path, @"^(/v\d\.\d)?/api").Success))
// {
// return false;
// }
// return true;
//});
diagnosticOptions.SetRequestRequestRule((serviceProvider, request) =>
{
if (serviceProvider == null || request == null)
{
return(false);
}
foreach (var rule in RequestRuleRegister.GetAll())
{
bool flag = rule.Invoke(serviceProvider, request);
if (!flag)
{
return(flag);
}
}
return(true);
});
services.AddHttpContextAccessor();
}
private static AggregateApplicationProcessor CreateApplicationProcessor(string[] args, Microsoft.Extensions.Logging.ILogger logger, IConfiguration configuration)
{
var diagnosticOptions = DiagnosticOptions.FromConfiguration(configuration);
var diagnosticsCollector = new DiagnosticsCollector(logger, diagnosticOptions);
// Print out what providers were selected and their values
diagnosticOptions.DumpDiagnostics(logger);
var processor = new AggregateApplicationProcessor(new IApplicationProcessor[] {
new EventPipeDiagnosticsRunner(logger, diagnosticsCollector),
new ProxyService(logger),
new DockerRunner(logger),
new ProcessRunner(logger, ProcessRunnerOptions.FromArgs(args)),
});
return(processor);
}
private DiagnosticResult(
ImmutableArray <DiagnosticLocation> spans,
bool suppressMessage,
string?message,
DiagnosticSeverity severity,
DiagnosticOptions options,
string id,
LocalizableString?messageFormat,
object?[]?messageArguments)
{
_spans = spans;
_suppressMessage = suppressMessage;
_message = message;
Severity = severity;
Options = options;
Id = id;
MessageFormat = messageFormat;
MessageArguments = messageArguments;
}
public DiagnosticController(IOptionsSnapshot <DiagnosticOptions> options)
{
_options = options.Value;
}
public DiagnosticResult WithOptions(DiagnosticOptions options)
{
return(new DiagnosticResult(Id, Message, Severity, options));
}
public DiagnosticController(IApplicationRequestContext requestContext, IOptionsMonitor <DiagnosticOptions> options)
{
_requestContext = requestContext;
_options = options.CurrentValue;
}
public DiagnosticController(IApplicationRequestContext requestContext, IOptions <DiagnosticOptions> options)
{
_requestContext = requestContext;
_options = options.Value;
}
