public void Initialize(ITelemetry telemetry) { try { var context = this.httpContextAccessor.HttpContext; if (context == null) { AspNetCoreEventSource.Instance.LogTelemetryInitializerBaseInitializeContextNull(); return; } if (context.RequestServices == null) { AspNetCoreEventSource.Instance.LogTelemetryInitializerBaseInitializeRequestServicesNull(); return; } var request = context.RequestServices.GetService<RequestTelemetry>(); if (request == null) { AspNetCoreEventSource.Instance.LogTelemetryInitializerBaseInitializeRequestNull(); return; } this.OnInitializeTelemetry(context, request, telemetry); } catch (Exception exp) { AspNetCoreEventSource.Instance.LogTelemetryInitializerBaseInitializeException(exp.ToString()); Debug.WriteLine(exp); } }
/// <summary> /// Implements initialization logic. /// </summary> /// <param name="platformContext">Http context.</param> /// <param name="requestTelemetry">Request telemetry object associated with the current request.</param> /// <param name="telemetry">Telemetry item to initialize.</param> protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry) { if (string.IsNullOrEmpty(telemetry.Context.Operation.SyntheticSource)) { if (platformContext != null) { var request = platformContext.GetRequest(); if (request != null && !string.IsNullOrEmpty(request.UserAgent)) { // We expect customers to configure telemetry initializer before they add it to active configuration // So we will not protect fiterPatterns array with locks (to improve perf) foreach (string pattern in this.filterPatterns) { if (!string.IsNullOrWhiteSpace(pattern) && request.UserAgent.IndexOf(pattern, StringComparison.OrdinalIgnoreCase) != -1) { telemetry.Context.Operation.SyntheticSource = "Bot"; return; } } } } } }
public void Initialize(ITelemetry telemetry) { if (!string.IsNullOrEmpty(this.appVersion)) { telemetry.Context.Component.Version = this.appVersion; } }
public void Send(ITelemetry item) { var timer = TimerStrategy(); if (timer == null || MessageBroker == null) { return; } if (item is DependencyTelemetry) { var dependency = item as DependencyTelemetry; var timelineMessage = new DependencyTelemetryTimelineMessage(dependency); timelineMessage.Offset = timer.Point().Offset.Subtract(dependency.Duration); MessageBroker.Publish(timelineMessage); } if (item is TraceTelemetry) { TraceTelemetry t = new TraceTelemetry(); var model = new TraceMessage { Category = "Application Insights", Message = t.SeverityLevel == null ? t.Message : t.SeverityLevel + ": " + t.Message, FromFirst = timer.Point().Offset, FromLast = CalculateFromLast(timer), IndentLevel = 0 }; MessageBroker.Publish(model); } messageBroker.Publish(item); }
protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry) { if (string.IsNullOrEmpty(telemetry.Context.Operation.Id)) { telemetry.Context.Operation.Id = requestTelemetry.Id; } }
/// <summary> /// Initializes/Adds operation id to the existing telemetry item. /// </summary> /// <param name="telemetryItem">Target telemetry item to add operation id.</param> public void Initialize(ITelemetry telemetryItem) { var itemContext = telemetryItem.Context.Operation; if (string.IsNullOrEmpty(itemContext.ParentId) || string.IsNullOrEmpty(itemContext.Id) || string.IsNullOrEmpty(itemContext.Name)) { var parentContext = AsyncLocalHelpers.GetCurrentOperationContext(); if (parentContext != null) { if (string.IsNullOrEmpty(itemContext.ParentId) && !string.IsNullOrEmpty(parentContext.ParentOperationId)) { itemContext.ParentId = parentContext.ParentOperationId; } if (string.IsNullOrEmpty(itemContext.Id) && !string.IsNullOrEmpty(parentContext.RootOperationId)) { itemContext.Id = parentContext.RootOperationId; } if (string.IsNullOrEmpty(itemContext.Name) && !string.IsNullOrEmpty(parentContext.RootOperationName)) { itemContext.Name = parentContext.RootOperationName; } } } }
/// <summary> /// Process a collected telemetry item. /// </summary> /// <param name="item">A collected Telemetry item.</param> public void Process(ITelemetry item) { if (this.SamplingPercentage < 100.0 - 1.0E-12) { // set sampling percentage on telemetry item, current codebase assumes it is the only one updating SamplingPercentage. var samplingSupportingTelemetry = item as ISupportSampling; if (samplingSupportingTelemetry != null) { samplingSupportingTelemetry.SamplingPercentage = this.SamplingPercentage; } if (!this.IsSampledIn(item)) { if (TelemetryChannelEventSource.Log.IsVerboseEnabled) { TelemetryChannelEventSource.Log.ItemSampledOut(item.ToString()); } return; } } this.Next.Process(item); }
/// <summary> /// Populates <see cref="ITelemetry.Sequence"/> with unique ID and sequential number. /// </summary> public void Initialize(ITelemetry telemetry) { if (string.IsNullOrEmpty(telemetry.Sequence)) { telemetry.Sequence = this.stablePrefix + Interlocked.Increment(ref this.currentNumber); } }
/// <summary> /// Base implementation of the initialization method. /// </summary> /// <param name="telemetry">Telemetry item to initialize.</param> public void Initialize(ITelemetry telemetry) { try { var platformContext = this.ResolvePlatformContext(); if (platformContext == null) { WebEventSource.Log.WebTelemetryInitializerNotExecutedOnNullHttpContext(); return; } if (platformContext.GetRequest() == null) { return; } var requestTelemetry = platformContext.ReadOrCreateRequestTelemetryPrivate(); this.OnInitializeTelemetry(platformContext, requestTelemetry, telemetry); } catch (Exception exc) { WebEventSource.Log.WebTelemetryInitializerFailure( this.GetType().FullName, exc.ToInvariantString()); } }
/// <summary> /// Initializes the given <see cref="Microsoft.ApplicationInsights.Channel.ITelemetry"/>. /// </summary> public void Initialize(ITelemetry telemetry) { if (String.IsNullOrWhiteSpace(telemetry.Context.Component.Version)) { telemetry.Context.Component.Version = _applicationVersion.Value; } }
public void Initialize(ITelemetry telemetry) { try { var context = this.httpContextAccessor.HttpContext; if (context == null) { //TODO: Diagnostics! return; } if (context.RequestServices == null) { //TODO: Diagnostics! return; } var request = context.RequestServices.GetService<RequestTelemetry>(); if (request == null) { //TODO: Diagnostics! return; } this.OnInitializeTelemetry(context, request, telemetry); } catch (Exception exp) { //TODO: Diagnostics! Debug.WriteLine(exp); } }
/// <summary> /// Initializes the telemetry. /// </summary> public void Initialize(ITelemetry telemetry) { if (telemetry.Context.Cloud.RoleInstance == null) { telemetry.Context.Cloud.RoleInstance = _hostName.Value; } }
/// <summary> /// Initializes the given <see cref="Microsoft.ApplicationInsights.Channel.ITelemetry"/>. /// </summary> /// <param name="telemetry"></param> public void Initialize(ITelemetry telemetry) { if (String.IsNullOrWhiteSpace(telemetry.Context.Session.Id)) { telemetry.Context.Session.Id = _sessionId.Value; } }
public void Initialize(ITelemetry telemetry) { var telemetryWithProperties = telemetry as ISupportProperties; if (telemetryWithProperties == null) return; // If already set, nothing to do. if (telemetryWithProperties.Properties.ContainsKey(Constants.ShellNameKey)) return; // Below algorithm copied from OrchardLog4netLogger. var ctx = HttpContext.Current; if (ctx == null) return; var runningShellTable = HostContainer.Resolve<IRunningShellTable>(); if (runningShellTable == null) return; var shellSettings = runningShellTable.Match(new HttpContextWrapper(ctx)); if (shellSettings == null) return; var orchardHost = HostContainer.Resolve<IOrchardHost>(); if (orchardHost == null) return; var shellContext = orchardHost.GetShellContext(shellSettings); if (shellContext == null || shellContext.Settings == null) return; telemetryWithProperties.Properties[Constants.ShellNameKey] = shellContext.Settings.Name; }
/// <summary> /// Implements initialization logic. /// </summary> /// <param name="platformContext">Http context.</param> /// <param name="requestTelemetry">Request telemetry object associated with the current request.</param> /// <param name="telemetry">Telemetry item to initialize.</param> protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry) { if (platformContext != null) { var request = platformContext.GetRequest(); if (request != null) { foreach (var pattern in this.filterPatterns) { if (pattern.RegularExpression != null && request.UserAgent != null) { var match = pattern.RegularExpression.Match(request.UserAgent); if (match.Success) { if (string.IsNullOrEmpty(telemetry.Context.Operation.SyntheticSource)) { telemetry.Context.Operation.SyntheticSource = !string.IsNullOrWhiteSpace(pattern.SourceName) ? pattern.SourceName : match.Value; return; } } } } } } }
public void Send(ITelemetry item) { lock ( lockobj ) { items.Add(item); } }
/// <summary> /// Initializes the given <see cref="Microsoft.ApplicationInsights.Channel.ITelemetry"/>. /// </summary> public void Initialize(ITelemetry telemetry) { if (String.IsNullOrWhiteSpace(telemetry.Context.Device.OperatingSystem)) { telemetry.Context.Device.OperatingSystem = _osVersion.Value; } }
public Car(ITelemetry telemetry, int carIdx) { this.telemetry = telemetry; this.carIdx = carIdx; this.driver = telemetry.SessionData.DriverInfo.CompetingDrivers[carIdx]; this.Details = new CarDetails(telemetry, carIdx); }
/// <summary> /// Sets <see cref="ITelemetry.Timestamp"/> to <see cref="DateTimeOffset.Now"/>. /// </summary> public void Initialize(ITelemetry telemetry) { if (telemetry.Timestamp == default(DateTimeOffset)) { telemetry.Timestamp = Clock.Instance.Time; } }
public void Initialize(ITelemetry telemetry) { if (HttpContext.Current == null) return; var requestId = HttpContext.Current.Items[Constants.RequestIdKey]; if (requestId == null || !string.IsNullOrEmpty(telemetry.Context.Operation.Id)) return; telemetry.Context.Operation.Id = requestId as string; }
public UnhandledExceptionTelemetryModuleTest() { this.channel.OnSend = telemetry => { sentTelemetry = telemetry; telemetrySent.Set(); }; }
protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry) { if (string.IsNullOrEmpty(telemetry.Context.Cloud.RoleInstance)) { var name = LazyInitializer.EnsureInitialized(ref this.roleInstanceName, this.GetMachineName); telemetry.Context.Cloud.RoleInstance = name; } }
/// <summary> /// Implements the <see cref="ITelemetryProcessor.Process"/> method by invoking the <see cref="OnProcess"/> callback. /// </summary> public void Process(ITelemetry item) { this.OnProcess(item); if (this.Next != null) { this.Next.Process(item); } }
public void Initialize(ITelemetry telemetry) { var owinRequestId = OwinRequestIdContext.Get(); if (owinRequestId != null) { telemetry.Context.Operation.Id = owinRequestId; } }
/// <summary> /// Implements the <see cref="ITelemetryProcessor.Initialize"/> method by invoking the process method /// </summary> public void Process(ITelemetry telemetry) { this.OnProcess(telemetry); if (this.next != null) { this.next.Process(telemetry); } }
/// <summary> /// Initializes <see cref="ITelemetry" /> device context. /// </summary> /// <param name="telemetry">The telemetry to initialize.</param> public void Initialize(ITelemetry telemetry) { if (string.IsNullOrEmpty(telemetry.Context.Cloud.RoleInstance)) { var name = LazyInitializer.EnsureInitialized(ref this.roleInstanceName, this.GetMachineName); telemetry.Context.Cloud.RoleInstance = name; } }
/// <summary> /// Adds a telemetry property for the version of SDK. /// </summary> public void Initialize(ITelemetry telemetry) { var version = LazyInitializer.EnsureInitialized(ref this.sdkVersion, this.GetAssemblyVersion); if (string.IsNullOrEmpty(telemetry.Context.Internal.SdkVersion)) { telemetry.Context.Internal.SdkVersion = version; } }
public async Task InvokeTracksExceptionThrownByNextMiddlewareAsHandledByPlatform() { RequestDelegate nextMiddleware = httpContext => { throw new Exception(); }; var middleware = new ExceptionTrackingMiddleware(nextMiddleware, CommonMocks.MockTelemetryClient(telemetry => this.sentTelemetry = telemetry)); await Assert.ThrowsAnyAsync<Exception>(() => middleware.Invoke(null)); Assert.Equal(ExceptionHandledAt.Platform, ((ExceptionTelemetry)sentTelemetry).HandledAt); }
/// <summary> /// Implements the <see cref="ITelemetryChannel.Send"/> method by invoking the <see cref="OnSend"/> callback. /// </summary> public void Send(ITelemetry item) { if (this.ThrowError) { throw new Exception("test error"); } this.OnSend(item); }
static void PopulateCarIdxPitStopCount(ITelemetry last, ITelemetry telemetry, int[] carIdxPitStopCount) { for (var i = 0; i < telemetry.CarIdxTrackSurface.Length; i++) if (last.CarIdxTrackSurface[i] != TrackLocation.InPitStall && telemetry.CarIdxTrackSurface[i] == TrackLocation.InPitStall) { carIdxPitStopCount[i] += 1; TraceInfo.WriteLine("{0} Driver {1} has pitted {2} times", telemetry.SessionTimeSpan, telemetry.Cars[i].Details.UserName, carIdxPitStopCount[i]); } }
public void Initialize(ITelemetry telemetry) { telemetry.Context.Operation.Id = OperationID; }
public static Parser Create( IServiceCollection services, StartServer startServer = null, Jupyter jupyter = null, StartStdIO startStdIO = null, StartHttp startHttp = null, Action onServerStarted = null, ITelemetry telemetry = null, IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null) { var operation = Log.OnEnterAndExit(); if (services is null) { throw new ArgumentNullException(nameof(services)); } var disposeOnQuit = new CompositeDisposable(); startServer ??= (startupOptions, invocationContext) => { operation.Info("constructing webhost"); var webHost = Program.ConstructWebHost(startupOptions); disposeOnQuit.Add(webHost); operation.Info("starting kestrel server"); webHost.Start(); onServerStarted?.Invoke(); webHost.WaitForShutdown(); operation.Dispose(); }; jupyter ??= JupyterCommand.Do; startStdIO ??= StdIOCommand.Do; startHttp ??= HttpCommand.Do; // Setup first time use notice sentinel. firstTimeUseNoticeSentinel ??= new FirstTimeUseNoticeSentinel(VersionSensor.Version().AssemblyInformationalVersion); var clearTextProperties = new[] { "frontend" }; // Setup telemetry. telemetry ??= new Telemetry.Telemetry( VersionSensor.Version().AssemblyInformationalVersion, firstTimeUseNoticeSentinel, "dotnet/interactive/cli"); var filter = new TelemetryFilter( Sha256Hasher.HashWithNormalizedCasing, clearTextProperties, (commandResult, directives, entryItems) => { // add frontend var frontendTelemetryAdded = false; foreach (var directive in directives) { switch (directive.Key) { case "vscode": case "jupyter": case "synapse": frontendTelemetryAdded = true; entryItems.Add(new KeyValuePair <string, string>("frontend", directive.Key)); break; } } if (!frontendTelemetryAdded) { if (commandResult.Command.Name == "jupyter") { entryItems.Add(new KeyValuePair <string, string>("frontend", "jupyter")); } else { entryItems.Add(new KeyValuePair <string, string>("frontend", "unknown")); } } }); var verboseOption = new Option <bool>( "--verbose", "Enable verbose logging to the console"); var logPathOption = new Option <DirectoryInfo>( "--log-path", "Enable file logging to the specified directory"); var pathOption = new Option <DirectoryInfo>( "--path", "Installs the kernelspecs to the specified directory") .ExistingOnly(); var defaultKernelOption = new Option <string>( "--default-kernel", description: "The default language for the kernel", getDefaultValue: () => "csharp").AddSuggestions("fsharp", "csharp", "pwsh"); var rootCommand = DotnetInteractive(); rootCommand.AddCommand(Jupyter()); rootCommand.AddCommand(StdIO()); rootCommand.AddCommand(HttpServer()); return(new CommandLineBuilder(rootCommand) .UseDefaults() .UseMiddleware(async(context, next) => { if (context.ParseResult.Errors.Count == 0) { telemetry.SendFiltered(filter, context.ParseResult); } // If sentinel does not exist, print the welcome message showing the telemetry notification. if (!Telemetry.Telemetry.SkipFirstTimeExperience && !firstTimeUseNoticeSentinel.Exists()) { context.Console.Out.WriteLine(); context.Console.Out.WriteLine(Telemetry.Telemetry.WelcomeMessage); firstTimeUseNoticeSentinel.CreateIfNotExists(); } await next(context); }) .Build()); RootCommand DotnetInteractive() { var command = new RootCommand { Name = "dotnet-interactive", Description = "Interactive programming for .NET." }; command.AddGlobalOption(logPathOption); command.AddGlobalOption(verboseOption); return(command); } Command Jupyter() { var httpPortRangeOption = new Option <HttpPortRange>( "--http-port-range", parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result), description: "Specifies the range of ports to use to enable HTTP services", isDefault: true); var jupyterCommand = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel") { defaultKernelOption, httpPortRangeOption, new Argument <FileInfo> { Name = "connection-file", Description = "The path to a connection file provided by Jupyter" }.ExistingOnly() }; jupyterCommand.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext, CancellationToken>(JupyterHandler); var installCommand = new Command("install", "Install the .NET kernel for Jupyter") { httpPortRangeOption, pathOption }; installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext, HttpPortRange, DirectoryInfo>(InstallHandler); jupyterCommand.AddCommand(installCommand); return(jupyterCommand); async Task <int> JupyterHandler(StartupOptions startupOptions, JupyterOptions options, IConsole console, InvocationContext context, CancellationToken cancellationToken) { var frontendEnvironment = new HtmlNotebookFrontendEnvironment(); var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions); kernel.Add( new JavaScriptKernel(), new[] { "js" }); services.AddKernel(kernel); await kernel.VisitSubkernelsAsync(async k => { switch (k) { case DotNetKernel dk: await dk.UseJupyterHelpersAsync(); break; } }); var clientSideKernelClient = new SignalRBackchannelKernelClient(); services.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile)) .AddSingleton(clientSideKernelClient) .AddSingleton(c => { return(new JupyterRequestContextScheduler(delivery => c.GetRequiredService <JupyterRequestContextHandler>() .Handle(delivery))); }) .AddSingleton(c => new JupyterRequestContextHandler(kernel)) .AddSingleton <IHostedService, Shell>() .AddSingleton <IHostedService, Heartbeat>(); var result = await jupyter(startupOptions, console, startServer, context); return(result); } Task <int> InstallHandler(IConsole console, InvocationContext context, HttpPortRange httpPortRange, DirectoryInfo path) { var jupyterInstallCommand = new JupyterInstallCommand(console, new JupyterKernelSpecInstaller(console), httpPortRange, path); return(jupyterInstallCommand.InvokeAsync()); } } Command HttpServer() { var httpPortOption = new Option <HttpPort>( "--http-port", description: "Specifies the port on which to enable HTTP services", parseArgument: result => { if (result.Tokens.Count == 0) { return(HttpPort.Auto); } var source = result.Tokens[0].Value; if (source == "*") { return(HttpPort.Auto); } if (!int.TryParse(source, out var portNumber)) { result.ErrorMessage = "Must specify a port number or *."; return(null); } return(new HttpPort(portNumber)); }, isDefault: true); var httpCommand = new Command("http", "Starts dotnet-interactive with kernel functionality exposed over http") { defaultKernelOption, httpPortOption }; httpCommand.Handler = CommandHandler.Create <StartupOptions, KernelHttpOptions, IConsole, InvocationContext>( (startupOptions, options, console, context) => { var frontendEnvironment = new BrowserFrontendEnvironment(); var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions); kernel.Add( new JavaScriptKernel(), new[] { "js" }); services.AddKernel(kernel) .AddSingleton(new SignalRBackchannelKernelClient()); onServerStarted ??= () => { console.Out.WriteLine("Application started. Press Ctrl+C to shut down."); }; return(startHttp(startupOptions, console, startServer, context)); }); return(httpCommand); } Command StdIO() { var httpPortRangeOption = new Option <HttpPortRange>( "--http-port-range", parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result), description: "Specifies the range of ports to use to enable HTTP services"); var httpPortOption = new Option <HttpPort>( "--http-port", description: "Specifies the port on which to enable HTTP services", parseArgument: result => { if (result.FindResultFor(httpPortRangeOption) is { } conflictingOption) { var parsed = result.Parent as OptionResult; result.ErrorMessage = $"Cannot specify both {conflictingOption.Token.Value} and {parsed.Token.Value} together"; return(null); } if (result.Tokens.Count == 0) { return(HttpPort.Auto); } var source = result.Tokens[0].Value; if (source == "*") { return(HttpPort.Auto); } if (!int.TryParse(source, out var portNumber)) { result.ErrorMessage = "Must specify a port number or *."; return(null); } return(new HttpPort(portNumber)); }); var workingDirOption = new Option <DirectoryInfo>( "--working-dir", () => new DirectoryInfo(Environment.CurrentDirectory), "Working directory to which to change after launching the kernel."); var stdIOCommand = new Command( "stdio", "Starts dotnet-interactive with kernel functionality exposed over standard I/O") { defaultKernelOption, httpPortRangeOption, httpPortOption, workingDirOption }; stdIOCommand.Handler = CommandHandler.Create <StartupOptions, StdIOOptions, IConsole, InvocationContext>( async(startupOptions, options, console, context) => { var isVsCode = context.ParseResult.Directives.Contains("vscode"); FrontendEnvironment frontendEnvironment = startupOptions.EnableHttpApi ? new HtmlNotebookFrontendEnvironment() : new BrowserFrontendEnvironment(); var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions); services.AddKernel(kernel); kernel.UseQuitCommand(); var kernelServer = kernel.CreateKernelServer(startupOptions.WorkingDir); if (startupOptions.EnableHttpApi) { var clientSideKernelClient = new SignalRBackchannelKernelClient(); if (isVsCode) { var frontEndKernel = kernelServer.GetFrontEndKernel("vscode"); kernel.Add(frontEndKernel); await kernel.VisitSubkernelsAsync(async k => { switch (k) { case DotNetKernel dk: await dk.UseVSCodeHelpersAsync(kernel); break; } }); services.AddSingleton(clientSideKernelClient); ((HtmlNotebookFrontendEnvironment)frontendEnvironment).RequiresAutomaticBootstrapping = false; kernel.Add( new JavaScriptKernel(clientSideKernelClient), new[] { "js" }); } else { services.AddSingleton(clientSideKernelClient); kernel.Add( new JavaScriptKernel(clientSideKernelClient), new[] { "js" }); } var _ = kernelServer.RunAsync(); onServerStarted ??= () => { kernelServer.NotifyIsReady(); }; await startHttp(startupOptions, console, startServer, context); } kernel.Add( new JavaScriptKernel(), new[] { "js" }); await startStdIO( startupOptions, kernelServer, console); }); return(stdIOCommand); }
/// <summary> /// Sends Telemetry for the end of an XUnit Test work item. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='xHelixJobToken'> /// </param> /// <param name='id'> /// The id returned from the /// {M:Helix.LifeTime.Web.Controllers.Api_2018_03_14.TelemetryApiController.StartXUnitWorkItem(System.String,System.String)} /// call. /// </param> /// <param name='exitCode'> /// The exitCode of this work item. /// </param> /// <param name='resultsXmlUri'> /// The Uri where XUnit v2 format test results can be accessed. /// </param> /// <param name='logUri'> /// The Uri where logs for this test run may be accessed. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task FinishXUnitWorkItemAsync(this ITelemetry operations, string xHelixJobToken, string id, int exitCode, string resultsXmlUri, string logUri = default(string), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { (await operations.FinishXUnitWorkItemWithHttpMessagesAsync(xHelixJobToken, id, exitCode, resultsXmlUri, logUri, null, cancellationToken).ConfigureAwait(false)).Dispose(); }
public static Parser Create( IServiceCollection services, StartServer startServer = null, Jupyter jupyter = null, StartKernelServer startKernelServer = null, ITelemetry telemetry = null, IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null) { if (services == null) { throw new ArgumentNullException(nameof(services)); } startServer ??= (startupOptions, invocationContext) => Program.ConstructWebHost(startupOptions).Run(); jupyter ??= JupyterCommand.Do; startKernelServer ??= async(startupOptions, kernel, console) => { var disposable = Program.StartToolLogging(startupOptions); if (kernel is KernelBase kernelBase) { kernelBase.RegisterForDisposal(disposable); } var server = new StandardIOKernelServer( kernel, Console.In, Console.Out); await server.Input.LastAsync(); }; // Setup first time use notice sentinel. firstTimeUseNoticeSentinel ??= new FirstTimeUseNoticeSentinel(VersionSensor.Version().AssemblyInformationalVersion); // Setup telemetry. telemetry ??= new Telemetry.Telemetry( VersionSensor.Version().AssemblyInformationalVersion, firstTimeUseNoticeSentinel); var filter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing); var verboseOption = new Option <bool>( "--verbose", "Enable verbose logging to the console"); var httpPortOption = new Option <int>( "--http-port", "Specifies the port on which to enable HTTP services"); var httpPortRangeOption = new Option <PortRange>( "--http-port-range", parseArgument: result => { if (result.Parent.Parent.Children.FirstOrDefault(c => c.Symbol == httpPortOption) is OptionResult conflictingOption) { var parsed = result.Parent as OptionResult; result.ErrorMessage = $"Cannot specify both {conflictingOption.Token.Value} and {parsed.Token.Value} together"; return(null); } var source = result.Tokens[0].Value; if (string.IsNullOrWhiteSpace(source)) { result.ErrorMessage = "Must specify a port range"; return(null); } var parts = source.Split(new[] { "-" }, StringSplitOptions.RemoveEmptyEntries); if (parts.Length != 2) { result.ErrorMessage = "Must specify a port range"; return(null); } if (!int.TryParse(parts[0], out var start) || !int.TryParse(parts[1], out var end)) { result.ErrorMessage = "Must specify a port range as StartPort-EndPort"; return(null); } if (start > end) { result.ErrorMessage = "Start port must be lower then end port"; return(null); } var pr = new PortRange(start, end); return(pr); }, description: "Specifies the range of port to use to enable HTTP services"); var logPathOption = new Option <DirectoryInfo>( "--log-path", "Enable file logging to the specified directory"); var defaultKernelOption = new Option <string>( "--default-kernel", description: "The default language for the kernel", getDefaultValue: () => "csharp"); var rootCommand = DotnetInteractive(); rootCommand.AddCommand(Jupyter()); rootCommand.AddCommand(KernelServer()); rootCommand.AddCommand(HttpServer()); return(new CommandLineBuilder(rootCommand) .UseDefaults() .UseMiddleware(async(context, next) => { if (context.ParseResult.Errors.Count == 0) { telemetry.SendFiltered(filter, context.ParseResult); } // If sentinel does not exist, print the welcome message showing the telemetry notification. if (!firstTimeUseNoticeSentinel.Exists() && !Telemetry.Telemetry.SkipFirstTimeExperience) { context.Console.Out.WriteLine(); context.Console.Out.WriteLine(Telemetry.Telemetry.WelcomeMessage); firstTimeUseNoticeSentinel.CreateIfNotExists(); } await next(context); }) .Build()); RootCommand DotnetInteractive() { var command = new RootCommand { Name = "dotnet-interactive", Description = "Interactive programming for .NET." }; command.AddOption(logPathOption); command.AddOption(verboseOption); command.AddOption(httpPortOption); return(command); } Command Jupyter() { var jupyterCommand = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel") { defaultKernelOption, logPathOption, verboseOption, httpPortOption, httpPortRangeOption, new Argument <FileInfo> { Name = "connection-file" }.ExistingOnly() }; jupyterCommand.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext>(JupyterHandler); var installCommand = new Command("install", "Install the .NET kernel for Jupyter") { logPathOption, verboseOption, httpPortRangeOption }; installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext, PortRange>(InstallHandler); jupyterCommand.AddCommand(installCommand); return(jupyterCommand); Task <int> JupyterHandler(StartupOptions startupOptions, JupyterOptions options, IConsole console, InvocationContext context) { services.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile)) .AddSingleton(_ => { var frontendEnvironment = new BrowserFrontendEnvironment { ApiUri = new Uri($"http://localhost:{startupOptions.HttpPort}") }; return(frontendEnvironment); }) .AddSingleton <FrontendEnvironment>(c => c.GetService <BrowserFrontendEnvironment>()) .AddSingleton(c => { return(CommandScheduler.Create <JupyterRequestContext>(delivery => c.GetRequiredService <ICommandHandler <JupyterRequestContext> >() .Trace() .Handle(delivery))); }) .AddSingleton(c => { var frontendEnvironment = c.GetRequiredService <BrowserFrontendEnvironment>(); var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions, c.GetRequiredService <HttpProbingSettings>()); return(kernel); }) .AddSingleton(c => new JupyterRequestContextHandler( c.GetRequiredService <IKernel>()) .Trace()) .AddSingleton <IHostedService, Shell>() .AddSingleton <IHostedService, Heartbeat>() ; return(jupyter(startupOptions, console, startServer, context)); } Task <int> InstallHandler(IConsole console, InvocationContext context, PortRange httpPortRange) => new JupyterInstallCommand(console, new JupyterKernelSpec(), httpPortRange).InvokeAsync(); } Command HttpServer() { var startKernelHttpCommand = new Command("http", "Starts dotnet-interactive with kernel functionality exposed over http") { defaultKernelOption, httpPortOption, logPathOption, httpPortRangeOption }; startKernelHttpCommand.Handler = CommandHandler.Create <StartupOptions, KernelHttpOptions, IConsole, InvocationContext>( (startupOptions, options, console, context) => { var frontendEnvironment = new BrowserFrontendEnvironment(); services .AddSingleton(_ => frontendEnvironment) .AddSingleton(c => CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions, null)); return(jupyter(startupOptions, console, startServer, context)); }); return(startKernelHttpCommand); } Command KernelServer() { var startKernelServerCommand = new Command( "stdio", "Starts dotnet-interactive with kernel functionality exposed over standard I/O") { defaultKernelOption, logPathOption, }; startKernelServerCommand.Handler = CommandHandler.Create <StartupOptions, KernelServerOptions, IConsole, InvocationContext>( (startupOptions, options, console, context) => startKernelServer( startupOptions, CreateKernel(options.DefaultKernel, new BrowserFrontendEnvironment(), startupOptions, null), console)); return(startKernelServerCommand); } }
protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry) { if (!string.IsNullOrEmpty(telemetry.Context.Location.Ip)) { //already populated return; } if (string.IsNullOrEmpty(requestTelemetry.Context.Location.Ip)) { string resultIp = null; foreach (var name in this.HeaderNames) { var headerValue = platformContext.Request.Headers[name]; if (!string.IsNullOrEmpty(headerValue)) { var ip = GetIpFromHeader(headerValue); ip = CutPort(ip); if (IsCorrectIpAddress(ip)) { resultIp = ip; break; } } } if (string.IsNullOrEmpty(resultIp)) { var connectionFeature = platformContext.Features.Get <IHttpConnectionFeature>(); if (connectionFeature != null) { resultIp = connectionFeature.RemoteIpAddress.ToString(); } } requestTelemetry.Context.Location.Ip = resultIp; } telemetry.Context.Location.Ip = requestTelemetry.Context.Location.Ip; }
public void Initialize(ITelemetry telemetry) { telemetry.Properties["customuserid"] = "your_id"; }
public static void AddEmployerAccountId(this ITelemetry telemetry, long employerAccountId) { telemetry.AddProperty("Employer Account Id", employerAccountId.ToString()); }
public static void TrackDependency(this ITelemetry telemetry, DependencyType dependencyType, string dependencyName, DateTimeOffset startTime, TimeSpan duration, bool success, Dictionary <string, string> properties = null) { telemetry.TrackDependency(dependencyType.ToString("G"), dependencyName, startTime, duration, success, properties); }
public void Initialize(ITelemetry telemetry) { if (telemetry == null) { return; } var httpContext = _httpContextAccessor.HttpContext; var items = httpContext?.Items; if (items != null) { if ((telemetry is RequestTelemetry || telemetry is EventTelemetry || telemetry is TraceTelemetry) && items.ContainsKey(BotActivityKey)) { if (items[BotActivityKey] is JObject body) { var userId = string.Empty; var from = body["from"]; if (!string.IsNullOrWhiteSpace(from.ToString())) { userId = (string)from["id"]; } var channelId = (string)body["channelId"]; var conversationId = string.Empty; var conversation = body["conversation"]; if (!string.IsNullOrWhiteSpace(conversation.ToString())) { conversationId = (string)conversation["id"]; } // Set the user id on the Application Insights telemetry item. telemetry.Context.User.Id = channelId + userId; // Set the session id on the Application Insights telemetry item. telemetry.Context.Session.Id = conversationId; var telemetryProperties = ((ISupportProperties)telemetry).Properties; // Set the activity id https://github.com/Microsoft/botframework-obi/blob/master/botframework-activity/botframework-activity.md#id if (!telemetryProperties.ContainsKey("activityId")) { telemetryProperties.Add("activityId", (string)body["id"]); } // Set the channel id https://github.com/Microsoft/botframework-obi/blob/master/botframework-activity/botframework-activity.md#channel-id if (!telemetryProperties.ContainsKey("channelId")) { telemetryProperties.Add("channelId", (string)channelId); } // Set the activity type https://github.com/Microsoft/botframework-obi/blob/master/botframework-activity/botframework-activity.md#type if (!telemetryProperties.ContainsKey("activityType")) { telemetryProperties.Add("activityType", (string)body["type"]); } } } } }
public JobsService(IPaymentLogger logger, ILifetimeScope lifetimeScope, ActorService actorService, ActorId actorId, ITelemetry telemetry) : base(actorService, actorId) { this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); this.lifetimeScope = lifetimeScope ?? throw new ArgumentNullException(nameof(lifetimeScope)); this.telemetry = telemetry ?? throw new ArgumentNullException(nameof(telemetry)); }
private static void SetCommonTelemetryDocumentData(ITelemetryDocument telemetryDocument, ITelemetry telemetry) { if (telemetry.Context == null) { return; } telemetryDocument.OperationName = TruncateValue(telemetry.Context.Operation?.Name); telemetryDocument.InternalNodeName = TruncateValue(telemetry.Context.GetInternalContext()?.NodeName); telemetryDocument.CloudRoleName = TruncateValue(telemetry.Context.Cloud?.RoleName); telemetryDocument.CloudRoleInstance = TruncateValue(telemetry.Context.Cloud?.RoleInstance); }
internal static int ProcessArgs(string[] args, ITelemetry telemetryClient = null) { // CommandLineApplication is a bit restrictive, so we parse things ourselves here. Individual apps should use CLA. var success = true; var command = string.Empty; var lastArg = 0; TopLevelCommandParserResult topLevelCommandParserResult = TopLevelCommandParserResult.Empty; using (IFirstTimeUseNoticeSentinel disposableFirstTimeUseNoticeSentinel = new FirstTimeUseNoticeSentinel()) { IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = disposableFirstTimeUseNoticeSentinel; IAspNetCertificateSentinel aspNetCertificateSentinel = new AspNetCertificateSentinel(); IFileSentinel toolPathSentinel = new FileSentinel( new FilePath( Path.Combine( CliFolderPathCalculator.DotnetUserProfileFolderPath, ToolPathSentinelFileName))); for (; lastArg < args.Length; lastArg++) { if (IsArg(args[lastArg], "d", "diagnostics")) { Environment.SetEnvironmentVariable(CommandContext.Variables.Verbose, bool.TrueString); CommandContext.SetVerbose(true); } else if (IsArg(args[lastArg], "version")) { PrintVersion(); return(0); } else if (IsArg(args[lastArg], "info")) { PrintInfo(); return(0); } else if (IsArg(args[lastArg], "h", "help") || args[lastArg] == "-?" || args[lastArg] == "/?") { HelpCommand.PrintHelp(); return(0); } else if (args[lastArg].StartsWith("-", StringComparison.OrdinalIgnoreCase)) { Reporter.Error.WriteLine($"Unknown option: {args[lastArg]}"); success = false; } else { // It's the command, and we're done! command = args[lastArg]; if (string.IsNullOrEmpty(command)) { command = "help"; } var environmentProvider = new EnvironmentProvider(); bool generateAspNetCertificate = environmentProvider.GetEnvironmentVariableAsBool("DOTNET_GENERATE_ASPNET_CERTIFICATE", true); bool skipFirstRunExperience = environmentProvider.GetEnvironmentVariableAsBool("DOTNET_SKIP_FIRST_TIME_EXPERIENCE", false); bool telemetryOptout = environmentProvider.GetEnvironmentVariableAsBool("DOTNET_CLI_TELEMETRY_OPTOUT", false); ReportDotnetHomeUsage(environmentProvider); topLevelCommandParserResult = new TopLevelCommandParserResult(command); var hasSuperUserAccess = false; if (IsDotnetBeingInvokedFromNativeInstaller(topLevelCommandParserResult)) { aspNetCertificateSentinel = new NoOpAspNetCertificateSentinel(); firstTimeUseNoticeSentinel = new NoOpFirstTimeUseNoticeSentinel(); toolPathSentinel = new NoOpFileSentinel(exists: false); hasSuperUserAccess = true; // When running through a native installer, we want the cache expansion to happen, so // we need to override this. skipFirstRunExperience = false; } var dotnetFirstRunConfiguration = new DotnetFirstRunConfiguration( generateAspNetCertificate: generateAspNetCertificate, skipFirstRunExperience: skipFirstRunExperience, telemetryOptout: telemetryOptout); ConfigureDotNetForFirstTimeUse( firstTimeUseNoticeSentinel, aspNetCertificateSentinel, toolPathSentinel, hasSuperUserAccess, dotnetFirstRunConfiguration, environmentProvider); break; } } if (!success) { HelpCommand.PrintHelp(); return(1); } if (telemetryClient == null) { telemetryClient = new Telemetry.Telemetry(firstTimeUseNoticeSentinel); } TelemetryEventEntry.Subscribe(telemetryClient.TrackEvent); TelemetryEventEntry.TelemetryFilter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing); } IEnumerable <string> appArgs = (lastArg + 1) >= args.Length ? Enumerable.Empty <string>() : args.Skip(lastArg + 1).ToArray(); if (CommandContext.IsVerbose()) { Console.WriteLine($"Telemetry is: {(telemetryClient.Enabled ? "Enabled" : "Disabled")}"); } TelemetryEventEntry.SendFiltered(topLevelCommandParserResult); int exitCode; if (BuiltInCommandsCatalog.Commands.TryGetValue(topLevelCommandParserResult.Command, out var builtIn)) { var parseResult = Parser.Instance.ParseFrom($"dotnet {topLevelCommandParserResult.Command}", appArgs.ToArray()); if (!parseResult.Errors.Any()) { TelemetryEventEntry.SendFiltered(parseResult); } exitCode = builtIn.Command(appArgs.ToArray()); } else { CommandResult result = CommandFactoryUsingResolver.Create( "dotnet-" + topLevelCommandParserResult.Command, appArgs, FrameworkConstants.CommonFrameworks.NetStandardApp15) .Execute(); exitCode = result.ExitCode; } telemetryClient.Flush(); return(exitCode); }
/// <summary> /// Processes telemetry item. /// </summary> /// <param name="item">Telemetry item to process.</param> public void Process(ITelemetry item) { this.samplingProcessor.Process(item); }
/// <summary> /// Method that subclasses can override to augment /// a telemetry item /// </summary> /// <param name="telemetry">The telemetry item</param> /// <param name="operation">The operation context</param> protected abstract void OnInitialize(ITelemetry telemetry, IOperationContext operation);
public MeditationTimer(string persistentObjectId, IWurmApi wurmApi, ILogger logger, ISoundManager soundManager, ITrayPopups trayPopups, ITelemetry telemetry) : base(persistentObjectId, trayPopups, logger, wurmApi, soundManager, telemetry) { cooldownUpdateOperation = new TriggerableAsyncOperation(UpdateMeditationCooldown); }
public void Send(ITelemetry item) { this.OnSend(item); }
/// <summary> /// Implements initialization logic. /// </summary> /// <param name="platformContext">Http context.</param> /// <param name="requestTelemetry">Request telemetry object associated with the current request.</param> /// <param name="telemetry">Telemetry item to initialize.</param> protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry) { if (telemetry == null) { throw new ArgumentNullException(nameof(telemetry)); } if (platformContext == null) { throw new ArgumentNullException(nameof(platformContext)); } if (string.IsNullOrEmpty(telemetry.Context.Operation.SyntheticSource)) { // platformContext and request != null checks are in the base class var request = platformContext.GetRequest(); var runIdHeader = request.UnvalidatedGetHeader(TestRunHeader); var locationHeader = request.UnvalidatedGetHeader(TestLocationHeader); if (!string.IsNullOrEmpty(runIdHeader) && !string.IsNullOrEmpty(locationHeader)) { telemetry.Context.Operation.SyntheticSource = GsmSource; // User id will be Pop location name and RunId (We cannot use just location because of sampling) telemetry.Context.User.Id = locationHeader + "_" + runIdHeader; telemetry.Context.Session.Id = runIdHeader; } } }
public void Initialize(ITelemetry telemetry) { telemetry.Context.Component.Version = Program.AssemblyInformationalVersion; }
protected void InitializeTelemetry(ITelemetry telemetry) { this.Telemetry = telemetry; }
public void Initialize(ITelemetry telemetry) { ISupportProperties propTelemetry = (ISupportProperties)telemetry; propTelemetry.Properties.TryAdd("Test", "TestValue"); }
private void ProcessTelemetry(ITelemetry telemetry) { // only process items that are going to the instrumentation key that our module is initialized with if (string.IsNullOrWhiteSpace(this.config?.InstrumentationKey) || !string.Equals(telemetry?.Context?.InstrumentationKey, this.config.InstrumentationKey, StringComparison.OrdinalIgnoreCase)) { return; } var telemetryAsRequest = telemetry as RequestTelemetry; var telemetryAsDependency = telemetry as DependencyTelemetry; var telemetryAsException = telemetry as ExceptionTelemetry; var telemetryAsEvent = telemetry as EventTelemetry; var telemetryAsTrace = telemetry as TraceTelemetry; // update aggregates bool?originalRequestTelemetrySuccessValue = null; if (telemetryAsRequest != null) { // special treatment for RequestTelemetry.Success originalRequestTelemetrySuccessValue = telemetryAsRequest.Success; telemetryAsRequest.Success = IsRequestSuccessful(telemetryAsRequest); this.UpdateRequestAggregates(telemetryAsRequest); } else if (telemetryAsDependency != null) { this.UpdateDependencyAggregates(telemetryAsDependency); } else if (telemetryAsException != null) { this.UpdateExceptionAggregates(); } // get a local reference, the accumulator might get swapped out at any time // in case we continue to process this configuration once the accumulator is out, increase the reference count so that this accumulator is not sent out before we're done CollectionConfigurationAccumulator configurationAccumulatorLocal = this.dataAccumulatorManager.CurrentDataAccumulator.CollectionConfigurationAccumulator; // if the accumulator is swapped out and a sample is created and sent out - all while between these two lines, this telemetry item gets lost // however, that is not likely to happen configurationAccumulatorLocal.AddRef(); try { // collect full telemetry items if (!this.disableFullTelemetryItems) { ITelemetryDocument telemetryDocument = null; IEnumerable <DocumentStream> documentStreams = configurationAccumulatorLocal.CollectionConfiguration.DocumentStreams; // !!! report runtime errors for filter groups? CollectionConfigurationError[] groupErrors; if (telemetryAsRequest != null) { telemetryDocument = this.CreateTelemetryDocument( telemetryAsRequest, documentStreams, documentStream => documentStream.RequestQuotaTracker, documentStream => documentStream.CheckFilters(telemetryAsRequest, out groupErrors), this.ConvertRequestToTelemetryDocument); } else if (telemetryAsDependency != null) { telemetryDocument = this.CreateTelemetryDocument( telemetryAsDependency, documentStreams, documentStream => documentStream.DependencyQuotaTracker, documentStream => documentStream.CheckFilters(telemetryAsDependency, out groupErrors), ConvertDependencyToTelemetryDocument); } else if (telemetryAsException != null) { telemetryDocument = this.CreateTelemetryDocument( telemetryAsException, documentStreams, documentStream => documentStream.ExceptionQuotaTracker, documentStream => documentStream.CheckFilters(telemetryAsException, out groupErrors), ConvertExceptionToTelemetryDocument); } else if (telemetryAsEvent != null) { telemetryDocument = this.CreateTelemetryDocument( telemetryAsEvent, documentStreams, documentStream => documentStream.EventQuotaTracker, documentStream => documentStream.CheckFilters(telemetryAsEvent, out groupErrors), ConvertEventToTelemetryDocument); } else if (telemetryAsTrace != null) { telemetryDocument = this.CreateTelemetryDocument( telemetryAsTrace, documentStreams, documentStream => documentStream.TraceQuotaTracker, documentStream => documentStream.CheckFilters(telemetryAsTrace, out groupErrors), ConvertTraceToTelemetryDocument); } if (telemetryDocument != null) { this.dataAccumulatorManager.CurrentDataAccumulator.TelemetryDocuments.Push(telemetryDocument); } this.dataAccumulatorManager.CurrentDataAccumulator.GlobalDocumentQuotaReached = this.globalQuotaTracker.QuotaExhausted; } // collect calculated metrics CollectionConfigurationError[] filteringErrors; string projectionError = null; if (telemetryAsRequest != null) { QuickPulseTelemetryProcessor.ProcessMetrics( configurationAccumulatorLocal, configurationAccumulatorLocal.CollectionConfiguration.RequestMetrics, telemetryAsRequest, out filteringErrors, ref projectionError); } else if (telemetryAsDependency != null) { QuickPulseTelemetryProcessor.ProcessMetrics( configurationAccumulatorLocal, configurationAccumulatorLocal.CollectionConfiguration.DependencyMetrics, telemetryAsDependency, out filteringErrors, ref projectionError); } else if (telemetryAsException != null) { QuickPulseTelemetryProcessor.ProcessMetrics( configurationAccumulatorLocal, configurationAccumulatorLocal.CollectionConfiguration.ExceptionMetrics, telemetryAsException, out filteringErrors, ref projectionError); } else if (telemetryAsEvent != null) { QuickPulseTelemetryProcessor.ProcessMetrics( configurationAccumulatorLocal, configurationAccumulatorLocal.CollectionConfiguration.EventMetrics, telemetryAsEvent, out filteringErrors, ref projectionError); } else if (telemetryAsTrace != null) { QuickPulseTelemetryProcessor.ProcessMetrics( configurationAccumulatorLocal, configurationAccumulatorLocal.CollectionConfiguration.TraceMetrics, telemetryAsTrace, out filteringErrors, ref projectionError); } // !!! report errors from string[] errors; and string projectionError; } finally { // special treatment for RequestTelemetry.Success - restore the value if (telemetryAsRequest != null) { telemetryAsRequest.Success = originalRequestTelemetrySuccessValue; } configurationAccumulatorLocal.Release(); } }
/// <summary> /// Initializes the telemetry context for a telemetry item /// </summary> /// <param name="telemetry">The telemetry item to augment</param> /// <param name="context">The operation context</param> /// <remarks> /// This variant is used to support easier testability by providing /// the operation context explicitly /// </remarks> public void Initialize(ITelemetry telemetry, IOperationContext context) { OnInitialize(telemetry, context); }
public ConnectCommand(IPreferences preferences, ITelemetry telemetry) { _preferences = preferences; _telemetry = telemetry; }
/// <summary> /// Sends Telemetry for the end of a build work item. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='xHelixJobToken'> /// </param> /// <param name='id'> /// The id returned from the /// {M:Helix.LifeTime.Web.Controllers.Api_2018_03_14.TelemetryApiController.StartBuildWorkItem(System.String,System.Uri)} /// call. /// </param> /// <param name='errorCount'> /// The number of errors reported for this build. /// </param> /// <param name='warningCount'> /// The number of warnings reported for this build. /// </param> /// <param name='logUri'> /// The Uri where logs for this build may be accessed. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task FinishBuildWorkItemAsync(this ITelemetry operations, string xHelixJobToken, string id, int errorCount, int warningCount, string logUri = default(string), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { (await operations.FinishBuildWorkItemWithHttpMessagesAsync(xHelixJobToken, id, errorCount, warningCount, logUri, null, cancellationToken).ConfigureAwait(false)).Dispose(); }
/// <summary> /// Sends Telemetry for work item logs. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='xHelixJobToken'> /// </param> /// <param name='id'> /// The id returned from the /// {M:Helix.LifeTime.Web.Controllers.Api_2018_03_14.TelemetryApiController.StartBuildWorkItem(System.String,System.Uri)} /// or /// {M:Helix.LifeTime.Web.Controllers.Api_2018_03_14.TelemetryApiController.StartXUnitWorkItem(System.String,System.String)} /// call. /// </param> /// <param name='logUri'> /// The Uri where logs may be accessed. /// </param> /// <param name='format'> /// The format that this log is in. /// </param> /// <param name='module'> /// The module/dll where these logs came from. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task LogAsync(this ITelemetry operations, string xHelixJobToken, string id, string logUri, string format = default(string), string module = default(string), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { (await operations.LogWithHttpMessagesAsync(xHelixJobToken, id, logUri, format, module, null, cancellationToken).ConfigureAwait(false)).Dispose(); }
public void Initialize(ITelemetry telemetry) { telemetry.Context.Cloud.RoleName = _roleName; telemetry.Context.Cloud.RoleInstance = Environment.MachineName; // @see: TelemetryConfigurationHelper }
/// <summary> /// Sends Telemetry for an error from a work item. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='xHelixJobToken'> /// </param> /// <param name='id'> /// The id returned from the /// {M:Helix.LifeTime.Web.Controllers.Api_2018_03_14.TelemetryApiController.StartBuildWorkItem(System.String,System.Uri)} /// or /// {M:Helix.LifeTime.Web.Controllers.Api_2018_03_14.TelemetryApiController.StartXUnitWorkItem(System.String,System.String)} /// call. /// </param> /// <param name='eid'> /// The id of the error. /// </param> /// <param name='message'> /// The error message. /// </param> /// <param name='logUri'> /// The Uri where error logs may be accessed. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task ErrorAsync(this ITelemetry operations, string xHelixJobToken, string id, string eid, string message = default(string), string logUri = default(string), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { (await operations.ErrorWithHttpMessagesAsync(xHelixJobToken, id, eid, message, logUri, null, cancellationToken).ConfigureAwait(false)).Dispose(); }
public void Initialize(ITelemetry telemetry) { telemetry.Context.GlobalProperties["WPF version"] = _wpfVersion; telemetry.Context.Component.Version = _appVersion; }
public SupplierService(IRepository repository, ILogger logger, ICache cache, ITelemetry telemetry) : base(repository, logger, cache, telemetry) { }