public static IHostBuilder Boot(IHostBuilder hostBuilder, string[] args, ILogger logger, Action <ISImplHostBuilder> configureDelegate)
{
var diagnostics = DiagnosticsCollector.Create();
// Write welcome to console
ConsoleWriteNameAndVersion();
// Parse command line arguments
var flags = ParseArgs(args);
// Init boot container
var bootContainer = InitBootContainer(hostBuilder, logger ?? CreateLogger(), flags, diagnostics);
// Init runtime services
RuntimeServices.Init(bootContainer.Resolve <IRuntimeServices>());
// Create .NET Stack host builder
var dotNetStackHostBuilder = bootContainer.Resolve <ISImplHostBuilder>();
// Start configuration of the host builder
dotNetStackHostBuilder.Configure(dotNetStackHostBuilder, stack =>
{
// Pre-installed module
stack.Use(() => new StackRuntimeModule(bootContainer));
// Installed modules
configureDelegate?.Invoke(stack);
});
return(dotNetStackHostBuilder);
}
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));
}
public async Task GaugeCallbacksAreFired()
{
// spin up a diagnostics collector
var diagnosticsCollector = new DiagnosticsCollector(new TestOutputLogger <DiagnosticsCollector>(_output));
// listen for our custom event source
diagnosticsCollector.AddSource(
new EventPipeProvider(
CustomEventSource.SourceName,
EventLevel.LogAlways,
0,
arguments: new Dictionary <string, string>()
{
{ "EventCounterIntervalSec", "1" }
}
)
);
// add a callback for our counters
var callCount = 0;
var resetEvent = new AutoResetEvent(false);
diagnosticsCollector.AddGaugeCallback(
CustomEventSource.SourceName,
CustomEventSource.GaugeName,
v =>
{
Interlocked.Increment(ref callCount);
resetEvent.Set();
}
);
// kick off the diagnostics collector
await((IHostedService)diagnosticsCollector).StartAsync(CancellationToken.None);
// update the gauge to kick off event processing
CustomEventSource.Instance.UpdateGauge();
// wait until the collector starts processing events
await diagnosticsCollector.WaitUntilProcessing();
try
{
// we should have received one event here
Assert.True(resetEvent.WaitOne(TimeSpan.FromSeconds(5)), "Did not receive initial gauge metric value");
Assert.Equal(1, callCount);
// update the gauge
CustomEventSource.Instance.UpdateGauge();
// shoulda received another event!
Assert.True(resetEvent.WaitOne(TimeSpan.FromSeconds(5)), "Did not receive updated gauge metric value");
Assert.Equal(2, callCount);
}
finally
{
await((IHostedService)diagnosticsCollector).StopAsync(CancellationToken.None);
}
}
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 static AggregateApplicationProcessor CreateApplicationProcessor(ReplicaRegistry replicaRegistry, HostOptions options, Microsoft.Extensions.Logging.ILogger logger)
{
var diagnosticsCollector = new DiagnosticsCollector(logger)
{
// Local run always uses metrics for the dashboard
MetricSink = new MetricSink(logger),
};
if (options.LoggingProvider != null &&
DiagnosticsProvider.TryParse(options.LoggingProvider, out var logging))
{
diagnosticsCollector.LoggingSink = new LoggingSink(logger, logging);
}
if (options.DistributedTraceProvider != null &&
DiagnosticsProvider.TryParse(options.DistributedTraceProvider, out var tracing))
{
diagnosticsCollector.TracingSink = new TracingSink(logger, tracing);
}
// Print out what providers were selected and their values
DumpDiagnostics(options, logger);
var processors = new List <IApplicationProcessor>
{
new EventPipeDiagnosticsRunner(logger, diagnosticsCollector),
new PortAssigner(logger),
new ProxyService(logger),
new HttpProxyService(logger),
new DockerImagePuller(logger),
new FuncFinder(logger),
new ReplicaMonitor(logger),
new DockerRunner(logger, replicaRegistry),
new ProcessRunner(logger, replicaRegistry, ProcessRunnerOptions.FromHostOptions(options))
};
// If the docker command is specified then transform the ProjectRunInfo into DockerRunInfo
if (options.Docker)
{
processors.Insert(0, new TransformProjectsIntoContainers(logger));
}
return(new AggregateApplicationProcessor(processors));
}
protected ValidationTest()
{
diags = new DiagnosticsCollector();
parser = EventManifestParser.CreateWithWinmeta(diags);
}
public EventPipeDiagnosticsRunner(ILogger logger, DiagnosticsCollector diagnosticsCollector)
{
_logger = logger;
_diagnosticsCollector = diagnosticsCollector;
}
private DiagnosticsCollector InitializeCollector()
{
var collector = new DiagnosticsCollector(this.logger)
{
SelectProcessTimeout = TimeSpan.FromSeconds(60),
};
foreach (var provider in options.Value.Providers)
{
if (!DiagnosticsProvider.WellKnownProviders.TryGetValue(provider.Key, out var wellKnown))
{
logger.LogError("Unknown provider type {Provider}. Skipping.", provider.Value);
continue;
}
switch (wellKnown.Kind)
{
case DiagnosticsProvider.ProviderKind.Logging:
{
if (collector.LoggingSink is object)
{
logger.LogError("Logging is already initialized. Skipping.");
continue;
}
logger.LogInformation(wellKnown.LogFormat, provider.Value);
collector.LoggingSink = new LoggingSink(logger, provider);
break;
}
case DiagnosticsProvider.ProviderKind.Metrics:
{
if (collector.MetricSink is object)
{
logger.LogError("Metrics is already initialized. Skipping.");
continue;
}
// TODO metrics
break;
}
case DiagnosticsProvider.ProviderKind.Tracing:
{
if (collector.TracingSink is object)
{
logger.LogError("Tracing is already initialized. Skipping.");
continue;
}
logger.LogInformation(wellKnown.LogFormat, provider.Value);
collector.TracingSink = new TracingSink(logger, provider);
break;
}
default:
logger.LogError("Unknown provider type. Skipping.");
break;
}
}
return(collector);
}
private static INanoContainer InitBootContainer(IHostBuilder hostBuilder, ILogger logger, RuntimeFlags flags, DiagnosticsCollector diagnostics)
{
var container = new NanoContainer.NanoContainer();
// Register container
container.Register <INanoContainer>(container);
// Register logging
container.Register <ILogger>(() => logger);
// Register parameters
container.Register <IHostBuilder>(hostBuilder);
container.Register <IDiagnosticsCollector>(diagnostics);
container.Register <RuntimeFlags>(flags);
// Register core services
container.Register <IModuleManager, ModuleManager>();
container.Register <IBootSequenceFactory, BootSequenceFactory>();
container.Register <IRuntimeServices, RuntimeServices>();
// Register host builder and boot manager
container.Register <IHostBootManager, HostBootManager>();
container.Register <ISImplHostBuilder, SImplHostBuilder>();
// register application builder and boot manager
container.Register <IApplicationBootManager, ApplicationBootManager>();
// Handle cli flags
if (flags.Diagnostics)
{
container.AddDiagnostics();
}
if (flags.Verbose)
{
container.AddVerbosity();
}
return(container);
}
