public void ConfigureServices(IServiceCollection services)
{
var traceConfig = TraceConfiguration.Create(GetSampleRate(), GetBufferOptions());
services.AddGoogleTrace(_projectId, traceConfig);
services.AddMvc();
}
private static TraceConfiguration CreateConfiguration(string outputFilename)
{
// Setup the configuration values.
uint circularBufferMB = 1024; // 1 GB
uint level = 5; // Verbose
// Create a new instance of EventPipeConfiguration.
TraceConfiguration config = new TraceConfiguration(outputFilename, circularBufferMB);
// Setup the provider values.
// Public provider.
string providerName = "e13c0d23-ccbc-4e12-931b-d9cc2eee27e4";
UInt64 keywords = 0x4c14fccbd;
// Enable the provider.
config.EnableProvider(providerName, keywords, level);
// Private provider.
providerName = "763fd754-7086-4dfe-95eb-c01a46faf4ca";
keywords = 0x4002000b;
// Enable the provider.
config.EnableProvider(providerName, keywords, level);
// Sample profiler.
providerName = "3c530d44-97ae-513a-1e6d-783e8f8e03a9";
keywords = 0x0;
// Enable the provider.
config.EnableProvider(providerName, keywords, level);
return(config);
}
public async Task <ILspLogger> CreateLoggerAsync(string serverTypeName, string?clientName, JsonRpc jsonRpc, CancellationToken cancellationToken)
{
var logName = $"Roslyn.{serverTypeName}.{clientName ?? "Default"}.{Interlocked.Increment(ref s_logHubSessionId)}";
var logId = new LogId(logName, new ServiceMoniker(typeof(LanguageServerTarget).FullName));
var serviceContainer = await _asyncServiceProvider.GetServiceAsync <SVsBrokeredServiceContainer, IBrokeredServiceContainer>(_threadingContext.JoinableTaskFactory).ConfigureAwait(false);
var service = serviceContainer.GetFullAccessServiceBroker();
var configuration = await TraceConfiguration.CreateTraceConfigurationInstanceAsync(service, ownsServiceBroker : true, cancellationToken).ConfigureAwait(false);
// Register the default log level as information.
// Loghub will take care of cleaning up older logs from past sessions / current session
// if it decides the log file sizes are too large.
var loggingLevel = SourceLevels.ActivityTracing | SourceLevels.Information;
var logOptions = new RpcContracts.Logging.LoggerOptions(new LoggingLevelSettings(loggingLevel));
var traceSource = await configuration.RegisterLogSourceAsync(logId, logOptions, cancellationToken).ConfigureAwait(false);
// Associate this trace source with the jsonrpc conduit. This ensures that we can associate logs we report
// with our callers and the operations they are performing.
jsonRpc.ActivityTracingStrategy = new CorrelationManagerTracingStrategy {
TraceSource = traceSource
};
return(new LogHubLspLogger(configuration, traceSource));
}
private static async Task <LogHubLspLogger?> CreateLoggerAsync(
VSShell.IAsyncServiceProvider?asyncServiceProvider,
string serverTypeName,
string?clientName,
JsonRpc jsonRpc,
CancellationToken cancellationToken)
{
if (asyncServiceProvider == null)
{
return(null);
}
var logName = $"Roslyn.{serverTypeName}.{clientName ?? "Default"}.{Interlocked.Increment(ref s_logHubSessionId)}";
var logId = new LogId(logName, new ServiceMoniker(typeof(LanguageServerTarget).FullName));
var serviceContainer = await VSShell.ServiceExtensions.GetServiceAsync <SVsBrokeredServiceContainer, IBrokeredServiceContainer>(asyncServiceProvider).ConfigureAwait(false);
var service = serviceContainer.GetFullAccessServiceBroker();
var configuration = await TraceConfiguration.CreateTraceConfigurationInstanceAsync(service, cancellationToken).ConfigureAwait(false);
var logOptions = new RpcContracts.Logging.LoggerOptions(new LoggingLevelSettings(SourceLevels.ActivityTracing | SourceLevels.Information));
var traceSource = await configuration.RegisterLogSourceAsync(logId, logOptions, cancellationToken).ConfigureAwait(false);
// Associate this trace source with the jsonrpc conduit. This ensures that we can associate logs we report
// with our callers and the operations they are performing.
jsonRpc.ActivityTracingStrategy = new CorrelationManagerTracingStrategy {
TraceSource = traceSource
};
return(new LogHubLspLogger(configuration, traceSource));
}
/// <summary>
/// Adds the needed services for Google Cloud Tracing. Used with <see cref="UseGoogleTrace"/>.
/// </summary>
/// <param name="services">The service collection. Cannot be null.</param>
/// <param name="projectId">Optional if running on Google App Engine or Google Compute Engine.
/// The Google Cloud Platform project ID. If unspecified and running on GAE or GCE the project ID will be
/// detected from the platform.</param>
/// <param name="config">Optional trace configuration, if unset the default will be used.</param>
/// <param name="client">Optional Trace client, if unset the default will be used.</param>
/// <param name="traceFallbackPredicate">Optional function to trace requests. If the trace header is not set
/// then this function will be called to determine if a given request should be traced. This will
/// not override trace headers. If the function returns true the request will be traced, if false
/// is returned the trace will not be traced and if null is returned it will not affect the
/// trace decision.</param>
public static void AddGoogleTrace(
this IServiceCollection services, string projectId = null,
TraceConfiguration config = null, TraceServiceClient client = null,
Func <HttpRequest, bool?> traceFallbackPredicate = null)
{
GaxPreconditions.CheckNotNull(services, nameof(services));
client = client ?? TraceServiceClient.Create();
config = config ?? TraceConfiguration.Create();
projectId = CommonUtils.GetAndCheckProjectId(projectId);
var consumer = ConsumerFactory <TraceProto> .GetConsumer(
new GrpcTraceConsumer(client), MessageSizer <TraceProto> .GetSize, config.BufferOptions);
var tracerFactory = new ManagedTracerFactory(projectId, consumer,
RateLimitingTraceOptionsFactory.Create(config), TraceIdFactory.Create());
services.AddScoped(CreateTraceHeaderContext);
services.AddSingleton <IManagedTracerFactory>(tracerFactory);
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddSingleton(CreateManagedTracer);
services.AddSingleton(CreateTraceHeaderPropagatingHandler);
services.AddSingleton(new ShouldTraceRequest(traceFallbackPredicate));
}
/// <summary>
/// Initializes a new instance of the <see cref="RazorViewEngine"/> class.
/// </summary>
/// <param name="configuration">The <see cref="IRazorConfiguration"/> that should be used by the engine.</param>
/// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
/// <param name="assemblyCatalog">An <see cref="IAssemblyCatalog"/> instance.</param>
public RazorViewEngine(IRazorConfiguration configuration, INancyEnvironment environment, IAssemblyCatalog assemblyCatalog)
{
this.razorAssemblyProvider = new RazorAssemblyProvider(configuration, assemblyCatalog);
this.viewRenderer = new CSharpRazorViewRenderer(this.razorAssemblyProvider);
this.razorConfiguration = configuration;
this.traceConfiguration = environment.GetValue<TraceConfiguration>();
this.AddDefaultNameSpaces(this.viewRenderer.Host);
}
/// <summary>
/// Initializes a new instance of the <see cref="RazorViewEngine"/> class.
/// </summary>
/// <param name="configuration">The <see cref="IRazorConfiguration"/> that should be used by the engine.</param>
/// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
/// <param name="assemblyCatalog">An <see cref="IAssemblyCatalog"/> instance.</param>
public RazorViewEngine(IRazorConfiguration configuration, INancyEnvironment environment, IAssemblyCatalog assemblyCatalog)
{
this.razorAssemblyProvider = new RazorAssemblyProvider(configuration, assemblyCatalog);
this.viewRenderer = new CSharpRazorViewRenderer(this.razorAssemblyProvider);
this.razorConfiguration = configuration;
this.traceConfiguration = environment.GetValue <TraceConfiguration>();
this.AddDefaultNameSpaces(this.viewRenderer.Host);
}
public CustomBootstrapper()
{
var builder = new ConfigurationBuilder()
.SetBasePath(RootPathProvider.GetRootPath())
.AddJsonFile("appsettings.json")
.AddEnvironmentVariables();
var tracingConfig = new TraceConfiguration(true, true);
Configuration = builder.Build();
}
private void CreateOutputFilter(TraceConfiguration traceConfiguration)
{
#region Create an output condition
// Create an output category to filter the trace results to only include
// features with the "Service Point" category assigned
traceConfiguration.OutputCondition = new CategoryComparison(CategoryOperator.IsEqual, "Service Point");
#endregion
}
private static async Task <TraceResultsSet> TraceAsync(Client c, string token)
{
TraceConfiguration traceConfiguration = new TraceConfiguration();
List <TraceLocation> tlList = new List <TraceLocation>();
tlList.Add(s_traceLocation);
string traceLocationList = JsonConvert.SerializeObject(tlList);
var result = c.TraceAsync(token, s_formatParam, s_versioSDE, "", "", s_traceType, traceLocationList, traceConfiguration.ToJson(), s_serverWebAdaptorName, s_utilityNetworkName);
return(await result);
}
/// <summary> Configures logging middleware to IApplicationBuilder instance </summary>
/// <param name="app">IApplicationBuilder</param>
/// <param name="configuration">IConfiguration</param>
/// <returns>Same IApplicationBuilder instance after configuring LoggingMiddleware</returns>
public static IApplicationBuilder UseLoggingServices(this IApplicationBuilder app, IHostingEnvironment environment, IConfiguration configuration,
Microsoft.Extensions.Logging.ILogger logger)
{
var traceConfiguration = new TraceConfiguration();
configuration.Bind(SerilogTrace, traceConfiguration);
logger.LogInformation(AddingLoggingMiddleware);
app.UseMiddleware <LoggingMiddleware>(traceConfiguration);
logger.LogInformation(LoggingMiddlewareAdded);
return(app);
}
private static TraceConfiguration EventPipeGetConfig(EventSource eventSource, EventKeywords keywords, string outputFile = "default.netperf")
{
// Setup the configuration values.
uint circularBufferMB = 1024; // 1 GB
uint level = 5;
// Create a new instance of EventPipeConfiguration.
TraceConfiguration config = new TraceConfiguration(outputFile, circularBufferMB);
// Enable the provider.
config.EnableProvider(eventSource.Name, (ulong)keywords, level);
return(config);
}
public LogHubLogger([Import(typeof(SAsyncServiceProvider))] IAsyncServiceProvider2 asyncServiceProvider)
{
asyncServiceProvider.GetServiceAsync <SVsBrokeredServiceContainer, IBrokeredServiceContainer>(throwOnFailure: true).ContinueWith(async(t) => {
var serviceBroker = t.Result.GetFullAccessServiceBroker();
Assumes.NotNull(serviceBroker);
// Setup logging using the log hub
using TraceConfiguration config = await TraceConfiguration.CreateTraceConfigurationInstanceAsync(serviceBroker, false);
SourceLevels sourceLevels = SourceLevels.Information | SourceLevels.ActivityTracing;
LoggerOptions logOptions = new(
requestedLoggingLevel: new LoggingLevelSettings(sourceLevels),
privacySetting: PrivacyFlags.MayContainPersonallyIdentifibleInformation | PrivacyFlags.MayContainPrivateInformation);
this._traceSource = await config.RegisterLogSourceAsync(new LogId("Microsoft.PythonTools", serviceId: null), logOptions, traceSource: null, isBootstrappedService: true, default);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="RazorViewEngine"/> class.
/// </summary>
/// <param name="configuration">The <see cref="IRazorConfiguration"/> that should be used by the engine.</param>
/// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
public RazorViewEngine(IRazorConfiguration configuration, INancyEnvironment environment)
{
this.viewRenderers = new List<IRazorViewRenderer>
{
new CSharpRazorViewRenderer(),
new VisualBasicRazorViewRenderer()
};
this.razorConfiguration = configuration;
this.traceConfiguration = environment.GetValue<TraceConfiguration>();
foreach (var renderer in this.viewRenderers)
{
this.AddDefaultNameSpaces(renderer.Host);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultStatusCodeHandler"/> type.
/// </summary>
/// <param name="responseNegotiator">The response negotiator.</param>
/// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
public DefaultStatusCodeHandler(IResponseNegotiator responseNegotiator, INancyEnvironment environment)
{
this.errorMessages = new Dictionary<HttpStatusCode, string>
{
{ HttpStatusCode.NotFound, "The resource you have requested cannot be found." },
{ HttpStatusCode.InternalServerError, "Something went horribly, horribly wrong while servicing your request." }
};
this.errorPages = new Dictionary<HttpStatusCode, string>
{
{ HttpStatusCode.NotFound, LoadResource("404.html") },
{ HttpStatusCode.InternalServerError, LoadResource("500.html") }
};
this.responseNegotiator = responseNegotiator;
this.configuration = environment.GetValue<TraceConfiguration>();
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultStatusCodeHandler"/> type.
/// </summary>
/// <param name="responseNegotiator">The response negotiator.</param>
/// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
public DefaultStatusCodeHandler(IResponseNegotiator responseNegotiator, INancyEnvironment environment)
{
this.errorMessages = new Dictionary <HttpStatusCode, string>
{
{ HttpStatusCode.NotFound, "The resource you have requested cannot be found." },
{ HttpStatusCode.InternalServerError, "Something went horribly, horribly wrong while servicing your request." }
};
this.errorPages = new Dictionary <HttpStatusCode, string>
{
{ HttpStatusCode.NotFound, LoadResource("404.html") },
{ HttpStatusCode.InternalServerError, LoadResource("500.html") }
};
this.responseNegotiator = responseNegotiator;
this.configuration = environment.GetValue <TraceConfiguration>();
}
/// <summary>
/// Initializes a new instance of the <see cref="RazorViewEngine"/> class.
/// </summary>
/// <param name="configuration">The <see cref="IRazorConfiguration"/> that should be used by the engine.</param>
/// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
/// <param name="assemblyCatalog">An <see cref="IAssemblyCatalog"/> instance.</param>
public RazorViewEngine(IRazorConfiguration configuration, INancyEnvironment environment, IAssemblyCatalog assemblyCatalog)
{
this.viewRenderers = new List <IRazorViewRenderer>
{
new CSharpRazorViewRenderer(assemblyCatalog),
new VisualBasicRazorViewRenderer(assemblyCatalog)
};
this.razorConfiguration = configuration;
this.assemblyCatalog = assemblyCatalog;
this.traceConfiguration = environment.GetValue <TraceConfiguration>();
foreach (var renderer in this.viewRenderers)
{
this.AddDefaultNameSpaces(renderer.Host);
}
}
// [START configure_services_trace]
public override void Init()
{
// [START_EXCLUDE]
string projectId = ConfigurationManager.AppSettings["projectId"];
// Confirm that projectId has been changed from placeholder value.
if (projectId == ("YOUR-PROJECT-ID"))
{
throw new Exception("Update Web.config and replace "
+ "YOUR-PROJECT-ID with your project id, and recompile.");
}
// [END_EXCLUDE]
base.Init();
TraceConfiguration traceConfig = TraceConfiguration
.Create(bufferOptions: BufferOptions.NoBuffer());
CloudTrace.Initialize(this, projectId, traceConfig);
}
void CreateTraceArgument()
{
#region Create a Trace Argument
IReadOnlyList <Element> startingPointList = new List <Element>();
// Code to fill in list of starting points goes here...
TraceArgument traceArgument = new TraceArgument(startingPointList);
TraceConfiguration traceConfiguration = new TraceConfiguration();
// Code to fill in trace configuration goes here...
traceArgument.Configuration = traceConfiguration;
#endregion
}
/// <summary>
/// Application Monitoring - Configures (prometheus) monitoring middleware to IApplicationBuilder instance
/// </summary>
/// <param name="app">IApplicationBuilder instance.</param>
/// <param name="configuration">IConfiguration instance.</param>
/// <param name="logger">ILogger instance.</param>
/// <returns>Same IApplicationBuilder instance after configuring MonitoringMiddleware</returns>
public static IApplicationBuilder UseMonitoringService(this IApplicationBuilder app, IConfiguration configuration, Microsoft.Extensions.Logging.ILogger logger)
{
var traceConfiguration = new TraceConfiguration();
configuration.Bind(SerilogTrace, traceConfiguration);
Metrics.SuppressDefaultMetrics();
var options = new HttpMiddlewareExporterOptions();
options.RequestDuration.Histogram = Metrics.CreateHistogram("http_request_duration",
"The duration of HTTP requests processed by an ASP.NET Core application",
new HistogramConfiguration()
{
// 500 ms to 2000 ms and infinite buckets
Buckets = Histogram.ExponentialBuckets(0.500, 2, 3),
LabelNames = new[] { "code", "method", "controller", "action" },
SuppressInitialValue = true,
});
logger.LogInformation(AddingMonitoringMiddleware);
var pattern = traceConfiguration.ExcludePattern;
if (options.InProgress.Enabled)
{
app.UseMiddleware <HttpMetricsInProgressMiddleware>(options.InProgress.Gauge, pattern);
}
if (options.RequestCount.Enabled)
{
app.UseMiddleware <HttpMetricsCountMiddleware>(options.RequestCount.Counter, pattern);
}
if (options.RequestDuration.Enabled)
{
app.UseMiddleware <HttpMetricsDurationMiddleware>(options.RequestDuration.Histogram, pattern);
}
app.UseMetricServer();
logger.LogInformation(MonitoringMiddlewareAdded);
return(app);
}
private static void CreateAndLoadConfigFile(string filename)
{
Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
string dir = Path.GetDirectoryName(config.FilePath);
string from = Path.Combine(dir, filename);
if (_configFile == null)
{
_configFile = Path.GetFileName(config.FilePath);
File.Copy(from, _configFile, overwrite: true);
TraceConfiguration.Register();
// Do not call Trace.Refresh() here since the first access should be tested without it.
}
else
{
File.Copy(from, _configFile, overwrite: true);
Trace.Refresh();
}
}
private static async Task <TraceResultsSet> TraceAsync(Client c, string token)
{
TraceConfiguration traceConfiguration = new TraceConfiguration();
List <TraceLocation> tlList = new List <TraceLocation>();
tlList.Add(s_traceLocation);
string traceLocationList = JsonConvert.SerializeObject(tlList);
Body body = new Body();
body.F = s_formatParam;
body.GdbVersion = s_versionSDE;
body.TraceConfiguration = JsonConvert.SerializeObject(traceConfiguration);
body.TraceLocations = tlList.ConvertAll <object>(item => (object)item).ToArray();
body.TraceType = s_traceType;
var result = c.TraceAsync(s_serverWebAdaptorName, s_utilityNetworkName, token, body);
return(await result);
}
/// <summary>
/// Adds the needed services for Google Cloud Tracing. Used with <see cref="UseGoogleTrace"/>.
/// </summary>
/// <param name="services">The service collection. Cannot be null.</param>
/// <param name="projectId">The Google Cloud Platform project ID. Cannot be null.</param>
/// <param name="config">Optional trace configuration, if unset the default will be used.</param>
/// <param name="clientTask">Optional task which produces the Trace client, if
/// unset the default will be used.</param>
public static void AddGoogleTrace(
this IServiceCollection services, string projectId,
TraceConfiguration config = null, Task <TraceServiceClient> clientTask = null)
{
GaxPreconditions.CheckNotNull(services, nameof(services));
GaxPreconditions.CheckNotNull(projectId, nameof(projectId));
clientTask = clientTask ?? TraceServiceClient.CreateAsync();
config = config ?? TraceConfiguration.Create();
IConsumer <TraceProto> consumer = ConsumerFactory <TraceProto> .GetConsumer(
new GrpcTraceConsumer(clientTask), MessageSizer <TraceProto> .GetSize, config.BufferOptions);
var tracerFactory = new ManagedTracerFactory(projectId, consumer,
RateLimitingTraceOptionsFactory.Create(config), TraceIdFactory.Create());
services.AddSingleton <IManagedTracerFactory>(tracerFactory);
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped(CreateTraceHeaderContext);
services.AddScoped(CreateManagedTracer);
}
public static TraceConfiguration GetConfig(EventSource eventSource, string outputFile = "default.netperf")
{
// Setup the configuration values.
uint circularBufferMB = 1024; // 1 GB
uint level = 5; //(uint)EventLevel.Informational;
TimeSpan profSampleDelay = TimeSpan.FromMilliseconds(1);
// Create a new instance of EventPipeConfiguration.
TraceConfiguration config = new TraceConfiguration(outputFile, circularBufferMB);
// Setup the provider values.
// Public provider.
string providerName = eventSource.Name;
UInt64 keywords = 0xffffffffffffffff;
// Enable the provider.
config.EnableProvider(providerName, keywords, level);
// Set the sampling rate.
config.SetSamplingRate(profSampleDelay);
return(config);
}
public async Task <ILspLogger> CreateLoggerAsync(string serverTypeName, string?clientName, JsonRpc jsonRpc, CancellationToken cancellationToken)
{
var logName = $"Roslyn.{serverTypeName}.{clientName ?? "Default"}.{Interlocked.Increment(ref s_logHubSessionId)}";
var logId = new LogId(logName, new ServiceMoniker(typeof(LanguageServerTarget).FullName));
var serviceContainer = await VSShell.ServiceExtensions.GetServiceAsync <SVsBrokeredServiceContainer, IBrokeredServiceContainer>(_asyncServiceProvider).ConfigureAwait(false);
var service = serviceContainer.GetFullAccessServiceBroker();
var configuration = await TraceConfiguration.CreateTraceConfigurationInstanceAsync(service, cancellationToken).ConfigureAwait(false);
// Register the default log level as warning to avoid creating log files in the hundreds of GB.
// This level can be overriden by setting the environment variable 'LogLevel' to the desired source level.
// See https://dev.azure.com/devdiv/DevDiv/_git/VS?path=%2Fsrc%2FPlatform%2FUtilities%2FImpl%2FLogHub%2FLocalTraceHub.cs&version=GBmain&line=142&lineEnd=143&lineStartColumn=1&lineEndColumn=1&lineStyle=plain&_a=contents
// This should be switched back to SourceLevels.Information once Loghub adds support for recyclying logs while VS is open.
// See https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1359778/
var loggingLevel = SourceLevels.ActivityTracing | SourceLevels.Warning;
// If VS was explicitly started with /log, then record all information logs as well.
// This is extremely useful for development so that F5 deployment automatically logs everything.
var wasVSStartedWithLogParameter = await _wasVSStartedWithLogParameterLazy.GetValueAsync(cancellationToken).ConfigureAwait(false);
if (wasVSStartedWithLogParameter)
{
loggingLevel |= SourceLevels.Information;
}
var logOptions = new RpcContracts.Logging.LoggerOptions(new LoggingLevelSettings(loggingLevel));
var traceSource = await configuration.RegisterLogSourceAsync(logId, logOptions, cancellationToken).ConfigureAwait(false);
// Associate this trace source with the jsonrpc conduit. This ensures that we can associate logs we report
// with our callers and the operations they are performing.
jsonRpc.ActivityTracingStrategy = new CorrelationManagerTracingStrategy {
TraceSource = traceSource
};
return(new LogHubLspLogger(configuration, traceSource));
}
static void Main(string[] args)
{
// Start the allocator thread.
//Task t = new Task(new Action(Allocator));
//t.Start();
string outputFilename = string fileName = System.IO.Path.GetTempPath() + Guid.NewGuid().ToString() + ".netperf";
TraceConfiguration config = CreateConfiguration(outputFilename);
Console.WriteLine("\tStart: Enable tracing.");
TraceControl.Enable(config);
Console.WriteLine("\tEnd: Enable tracing.\n");
Console.WriteLine("\tStart: Allocation.");
// Allocate for allocIterations iterations.
for (int i = 0; i < allocIterations; i++)
{
GC.KeepAlive(new object());
}
Console.WriteLine("\tEnd: Allocation.\n");
Console.WriteLine("\tStart: Disable tracing.");
TraceControl.Disable();
Console.WriteLine("\tEnd: Disable tracing.\n");
FileInfo outputMeta = new FileInfo(outputFilename);
Console.WriteLine("\tCreated {0} bytes of data", FileInfo.Length);
if (keepOutput)
{
Console.WriteLine(String.Fromat("\tOutput file: {0}", outputFilename));
}
else
{
System.IO.File.Delete(outputFilename);
}
}
public void GetTraceConfiguration_returns_the_correct_trace_configuration_for_given_traceConfigurationId()
{
var traceRepositoryMock = new Mock <ITraceRepository>();
var sut = new TraceController(traceRepositoryMock.Object, null, null);
var traceId = Guid.NewGuid();
var traceConfiguration = new TraceConfiguration()
{
CreationDate = DateTime.Now,
EndDate = DateTime.Now.AddMinutes(2),
Id = traceId,
LinkId = Guid.NewGuid(),
StartDate = DateTime.Now
};
traceRepositoryMock.Setup(t => t.GetTraceConfiguration(traceId))
.Returns(traceConfiguration);
var response = sut.GetTraceConfiguration(traceId) as OkNegotiatedContentResult <TraceConfiguration>;
traceRepositoryMock.VerifyAll();
response.Content.Should().BeSameAs(traceConfiguration);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// [START configure_services_logging]
// [START configure_services_error_reporting]
services.AddOptions();
services.Configure <StackdriverOptions>(
Configuration.GetSection("Stackdriver"));
// [END configure_services_logging]
services.AddGoogleExceptionLogging(
Configuration["Stackdriver:ProjectId"],
Configuration["Stackdriver:ServiceName"],
Configuration["Stackdriver:Version"]);
// [END configure_services_error_reporting]
// [START configure_services_trace]
// Add trace service.
TraceConfiguration traceConfig = TraceConfiguration.Create(bufferOptions: BufferOptions.NoBuffer());
services.AddGoogleTrace(Configuration["Stackdriver:ProjectId"], traceConfig);
// [END configure_services_trace]
// Add framework services.
services.AddMvc();
}
private void CheckConfiguration()
{
if (IntegrationOptionsProvider == null)
{
return;
}
var now = DateTime.Now;
if (now - configLastChecked < TimeSpan.FromSeconds(10))
{
return;
}
var integrationOptions = IntegrationOptionsProvider.GetOptions();
if (traceConfiguration.HasChanged(integrationOptions))
{
traceConfiguration = new TraceConfiguration(integrationOptions);
OnTraceConfigChanged();
}
configLastChecked = now;
}
public IHttpActionResult Create(StartTrace startTrace)
{
if (startTrace.Minutes < 1)
{
return(BadRequest("Tracking must be enabled for one minute at least."));
}
if (startTrace.Minutes > 10)
{
return(BadRequest("Tracking can only be enabled for ten minutes at most."));
}
var traceConfiguration = new TraceConfiguration
{
StartDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow.AddMinutes(startTrace.Minutes),
LinkId = startTrace.LinkId
};
_traceRepository.Create(traceConfiguration);
// TODO: Location
return(Created("", traceConfiguration));
}
public void Create(TraceConfiguration traceConfiguration)
{
using (var context = new RelayContext())
{
var link = new DbLink
{
Id = traceConfiguration.LinkId
};
context.Links.Attach(link);
context.TraceConfigurations.Add(new DbTraceConfiguration
{
CreationDate = DateTime.UtcNow,
EndDate = traceConfiguration.EndDate,
Id = Guid.NewGuid(),
Link = link,
LinkId = traceConfiguration.LinkId,
StartDate = traceConfiguration.StartDate
});
context.SaveChanges();
}
}
public void IsRunning_returns_true_when_trace_is_running_and_no_old_trace_is_in_configuration_list()
{
var traceRepositoryMock = new Mock <ITraceRepository>();
var sut = new TraceController(traceRepositoryMock.Object, null, null);
var connectionId = Guid.NewGuid();
var traceConfiguration = new TraceConfiguration()
{
CreationDate = DateTime.Now,
EndDate = DateTime.Now.AddMinutes(2),
Id = Guid.NewGuid(),
LinkId = connectionId,
StartDate = DateTime.Now
};
traceRepositoryMock.Setup(t => t.GetRunningTranceConfiguration(connectionId))
.Returns(traceConfiguration);
var response = sut.IsRunning(connectionId) as OkNegotiatedContentResult <RunningTraceConfiguration>;
traceRepositoryMock.VerifyAll();
response.Content.IsRunning.Should().BeTrue();
response.Content.TraceConfiguration.Should().BeSameAs(traceConfiguration);
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRequestTraceFactory"/> class.
/// </summary>
/// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
public DefaultRequestTraceFactory(INancyEnvironment environment)
{
this.configuration = environment.GetValue<TraceConfiguration>();
}
/// <summary>
/// Initializes a new instance of the <see cref="NancyRazorErrorView"/> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="traceConfiguration">A <see cref="TraceConfiguration"/> instance.</param>
public NancyRazorErrorView(string message, TraceConfiguration traceConfiguration)
{
this.traceConfiguration = traceConfiguration;
this.Message = message;
}
/// <summary>
/// Initializes a new instance of the <see cref="ViewProcessor"/> class,
/// with the provided <paramref name="viewFactory"/>.
/// </summary>
/// <param name="viewFactory">The view factory that should be used to render views.</param>
/// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
public ViewProcessor(IViewFactory viewFactory, INancyEnvironment environment)
{
this.viewFactory = viewFactory;
this.traceConfiguration = environment.GetValue<TraceConfiguration>();
}
private void CheckConfiguration()
{
if (IntegrationOptionsProvider == null)
return;
var now = DateTime.Now;
if (now - configLastChecked < TimeSpan.FromSeconds(10))
return;
var integrationOptions = IntegrationOptionsProvider.GetOptions();
if (traceConfiguration.HasChanged(integrationOptions))
{
traceConfiguration = new TraceConfiguration(integrationOptions);
OnTraceConfigChanged();
}
configLastChecked = now;
}
/// <summary>
/// Initializes a new instance of the <see cref="FavIconApplicationStartup"/> class, with the
/// provided <see cref="IRootPathProvider"/> instance.
/// </summary>
/// <param name="rootPathProvider">The <see cref="IRootPathProvider"/> that should be used to scan for a favicon.</param>
/// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
public FavIconApplicationStartup(IRootPathProvider rootPathProvider, INancyEnvironment environment)
{
FavIconApplicationStartup.rootPathProvider = rootPathProvider;
FavIconApplicationStartup.traceConfiguration = environment.GetValue<TraceConfiguration>();
}
/// <summary>
/// Initializes a new instance of the <see cref="ViewProcessor"/> class,
/// with the provided <paramref name="viewFactory"/>.
/// </summary>
/// <param name="viewFactory">The view factory that should be used to render views.</param>
/// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
public ViewProcessor(IViewFactory viewFactory, INancyEnvironment environment)
{
this.viewFactory = viewFactory;
this.traceConfiguration = environment.GetValue <TraceConfiguration>();
}
/// <summary>
/// Processes the command line.
/// </summary>
/// <param name="ignoreUnknownArguments">if set to <c>true</c> unknown arguments are ignored.</param>
/// <returns>
/// True if the arguments were processed; False otherwise.
/// </returns>
public bool ProcessCommandLine(bool ignoreUnknownArguments)
{
TraceConfiguration config = new TraceConfiguration();
config.OutputFilePath = "%CommonApplicationData%\\OPC Foundation\\Logs\\Default.InstallLog.txt";
config.DeleteOnLoad = false;
config.TraceMasks = 1023;
config.ApplySettings();
string[] args = Environment.GetCommandLineArgs();
if (args.Length <= 1)
{
return false;
}
return ProcessCommandLine(ignoreUnknownArguments, args);
}
