/// <summary>Snippet for CreateSpan</summary> public void CreateSpanRequestObject() { // Snippet: CreateSpan(Span, CallSettings) // Create client TraceServiceClient traceServiceClient = TraceServiceClient.Create(); // Initialize request argument(s) Span request = new Span { SpanName = SpanName.FromProjectTraceSpan("[PROJECT]", "[TRACE]", "[SPAN]"), SpanId = "", ParentSpanId = "", DisplayName = new TruncatableString(), StartTime = new Timestamp(), EndTime = new Timestamp(), Attributes = new Span.Types.Attributes(), StackTrace = new StackTrace(), TimeEvents = new Span.Types.TimeEvents(), Links = new Span.Types.Links(), Status = new Status(), SameProcessAsParentSpan = new bool?(), ChildSpanCount = new int?(), }; // Make the request Span response = traceServiceClient.CreateSpan(request); // End snippet }
/// <summary> /// Creates a <see cref="SimpleManagedTracer"/> with a <see cref="GrpcTraceConsumer"/>. /// </summary> private IManagedTracer CreateTracer() { string traceId = _traceIdFactory.NextId(); var consumer = new GrpcTraceConsumer(TraceServiceClient.Create()); return(SimpleManagedTracer.Create(consumer, _projectId, traceId, null)); }
/// <summary>Snippet for CreateSpanAsync</summary> public async Task CreateSpanRequestObjectAsync() { // Snippet: CreateSpanAsync(Span, CallSettings) // Additional: CreateSpanAsync(Span, CancellationToken) // Create client TraceServiceClient traceServiceClient = await TraceServiceClient.CreateAsync(); // Initialize request argument(s) Span request = new Span { SpanName = SpanName.FromProjectTraceSpan("[PROJECT]", "[TRACE]", "[SPAN]"), SpanId = "", ParentSpanId = "", DisplayName = new TruncatableString(), StartTime = new Timestamp(), EndTime = new Timestamp(), Attributes = new Span.Types.Attributes(), StackTrace = new StackTrace(), TimeEvents = new Span.Types.TimeEvents(), Links = new Span.Types.Links(), Status = new Status(), SameProcessAsParentSpan = false, ChildSpanCount = 0, }; // Make the request Span response = await traceServiceClient.CreateSpanAsync(request); // End snippet }
public static int Main(string[] args) { // Read projectId from args if (args.Length != 1) { Console.WriteLine("Usage: Project ID must be passed as first argument."); Console.WriteLine(); return(1); } string projectId = args[0]; // Create client TraceServiceClient client = TraceServiceClient.Create(); // Initialize request argument(s) string projectId2 = projectId; // Call API method PagedEnumerable <ListTracesResponse, Trace> pagedResponse = client.ListTraces(projectId2); // Show the result foreach (var item in pagedResponse) { Console.WriteLine(item); } // Success Console.WriteLine("Smoke test passed OK"); return(0); }
public static int Main(string[] args) { // Read projectId from args if (args.Length != 1) { Console.WriteLine("Usage: Project ID must be passed as first argument."); Console.WriteLine(); return(1); } string projectId = args[0]; // Create client TraceServiceClient client = TraceServiceClient.Create(); // Initialize request argument(s) ProjectName name = new ProjectName(projectId); IEnumerable <Span> spans = new List <Span>(); // Call API method client.BatchWriteSpans(name, spans); // Success Console.WriteLine("Smoke test passed OK"); return(0); }
/// <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)); }
public async Task ListTracesAsync() { // Snippet: ListTracesAsync(string,string,int?,CallSettings) // Create client TraceServiceClient traceServiceClient = TraceServiceClient.Create(); // Initialize request argument(s) string projectId = ""; // Make the request IPagedAsyncEnumerable <ListTracesResponse, Trace> response = traceServiceClient.ListTracesAsync(projectId); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Trace item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over fixed-sized pages, lazily performing RPCs as required int pageSize = 10; IAsyncEnumerable <FixedSizePage <Trace> > fixedSizePages = response.AsPages().WithFixedSize(pageSize); await fixedSizePages.ForEachAsync((FixedSizePage <Trace> page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Trace item in page) { Console.WriteLine(item); } }); // End snippet }
/// <summary> /// Configures Google Cloud Trace for dependency injection. /// </summary> public static IServiceCollection AddGoogleTrace(this IServiceCollection services, TraceServiceOptions options = null) { GaxPreconditions.CheckNotNull(services, nameof(services)); var client = options?.Client ?? TraceServiceClient.Create(); var traceOptions = options?.Options ?? TraceOptions.Create(); var projectId = Project.GetAndCheckProjectId(options?.ProjectId); var consumer = ManagedTracer.CreateConsumer(client, traceOptions); var tracerFactory = ManagedTracer.CreateFactory(projectId, consumer, traceOptions); services.AddSingleton(tracerFactory); services.AddSingleton(ManagedTracer.CreateDelegatingTracer(ContextTracerManager.GetCurrentTracer)); // On .Net Standard 2.0 or higher, we can use the System.Net.Http.IHttpClientFactory defined in Microsoft.Extensions.Http, // for which we need a DelegatingHandler with no InnerHandler set. // we register factories for the UnchainedTraceHeaderPropagatingHandler. #pragma warning disable CS0618 // Type or member is obsolete // This factory we register for backwards compatibility only. // We can remove it on our next major version as we are making UnchainedTraceHeaderPropagatingHandler // obsolete as well. services.AddTransient(UnchainedTraceHeaderPropagatingHandlerFactory); #pragma warning restore CS0618 // Type or member is obsolete // This is the new factory, that takes trace custom labels into account. return(services.AddSingleton <OutgoingGoogleTraceHandlerFactory>()); }
public TraceTest() { _projectId = Utils.GetProjectIdFromEnvironment(); _testId = Utils.GetTestId(); _startTime = Timestamp.FromDateTime(DateTime.UtcNow); _client = TraceServiceClient.Create(); }
/// <summary> /// Adds the needed services for Google Cloud Tracing. Used with <see cref="UseGoogleTrace"/>. /// </summary> /// <param name="services">The service collection. Must not be null.</param> /// <param name="setupAction">Action to set up options. Must not be null.</param> /// <remarks> /// If <see cref="RetryOptions.ExceptionHandling"/> is set to <see cref="ExceptionHandling.Propagate"/> /// and the <see cref="RequestDelegate"/> executed by this middleware throws ad exception and this /// diagnostics library also throws an exception trying to report it and <see cref="AggregateException"/> /// with both exceptions will be thrown. Otherwise only the exception from the <see cref="RequestDelegate"/> /// will be thrown. /// </remarks> public static IServiceCollection AddGoogleTrace( this IServiceCollection services, Action <TraceServiceOptions> setupAction) { GaxPreconditions.CheckNotNull(services, nameof(services)); GaxPreconditions.CheckNotNull(setupAction, nameof(setupAction)); var serviceOptions = new TraceServiceOptions(); setupAction(serviceOptions); var client = serviceOptions.Client ?? TraceServiceClient.Create(); var options = serviceOptions.Options ?? TraceOptions.Create(); var traceFallbackPredicate = serviceOptions.TraceFallbackPredicate ?? TraceDecisionPredicate.Default; var projectId = Project.GetAndCheckProjectId(serviceOptions.ProjectId); var consumer = ManagedTracer.CreateConsumer(client, options); var tracerFactory = ManagedTracer.CreateTracerFactory(projectId, consumer, options); services.AddScoped(CreateTraceHeaderContext); services.AddSingleton(tracerFactory); services.AddHttpContextAccessor(); services.AddSingleton(ManagedTracer.CreateDelegatingTracer(ContextTracerManager.GetCurrentTracer)); // On .Net Standard 2.0 or higher, we can use the System.Net.Http.IHttpClientFactory defined in Microsoft.Extensions.Http, // for which we need a DelagatingHandler with no InnerHandler set. This is the recommended way. // It should be registered as follows. services.AddTransient(sp => new UnchainedTraceHeaderPropagatingHandler(ContextTracerManager.GetCurrentTracer)); // This is to be used for explicitly creating an HttpClient instance. Valid for all platforms. services.AddSingleton(new TraceHeaderPropagatingHandler(ContextTracerManager.GetCurrentTracer)); return(services.AddSingleton(traceFallbackPredicate)); }
/// <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="setupAction">Action to set up options. Cannot be null.</param> /// <remarks> /// If <see cref="RetryOptions.ExceptionHandling"/> is set to <see cref="ExceptionHandling.Propagate"/> /// and the <see cref="RequestDelegate"/> executed by this middleware throws ad exception and this /// diagnostics library also throws an exception trying to report it and <see cref="AggregateException"/> /// with both exceptions will be thrown. Otherwise only the exception from the <see cref="RequestDelegate"/> /// will be thrown. /// </remarks> public static void AddGoogleTrace( this IServiceCollection services, Action <TraceServiceOptions> setupAction) { GaxPreconditions.CheckNotNull(services, nameof(services)); GaxPreconditions.CheckNotNull(setupAction, nameof(setupAction)); var serviceOptions = new TraceServiceOptions(); setupAction(serviceOptions); var client = serviceOptions.Client ?? TraceServiceClient.Create(); var options = serviceOptions.Options ?? TraceOptions.Create(); var traceFallbackPredicate = serviceOptions.TraceFallbackPredicate ?? TraceDecisionPredicate.Default; var projectId = Project.GetAndCheckProjectId(serviceOptions.ProjectId); var consumer = ManagedTracer.CreateConsumer(client, options); var tracerFactory = ManagedTracer.CreateTracerFactory(projectId, consumer, options); services.AddScoped(CreateTraceHeaderContext); services.AddSingleton <Func <TraceHeaderContext, IManagedTracer> >(tracerFactory); services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); services.AddSingleton(CreateManagedTracer); services.AddSingleton(CreateTraceHeaderPropagatingHandler); services.AddSingleton(traceFallbackPredicate); }
/// <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="setupAction">Action to set up options. Cannot be null.</param> public static void AddGoogleTrace( this IServiceCollection services, Action <TraceServiceOptions> setupAction) { GaxPreconditions.CheckNotNull(services, nameof(services)); GaxPreconditions.CheckNotNull(setupAction, nameof(setupAction)); var serviceOptions = new TraceServiceOptions(); setupAction(serviceOptions); var client = serviceOptions.Client ?? TraceServiceClient.Create(); var options = serviceOptions.Options ?? TraceOptions.Create(); var traceFallbackPredicate = serviceOptions.TraceFallbackPredicate ?? TraceDecisionPredicate.Default; var projectId = CommonUtils.GetAndCheckProjectId(serviceOptions.ProjectId); var consumer = ConsumerFactory <TraceProto> .GetConsumer( new GrpcTraceConsumer(client), MessageSizer <TraceProto> .GetSize, options.BufferOptions, options.RetryOptions); var tracerFactory = new ManagedTracerFactory(projectId, consumer, RateLimitingTraceOptionsFactory.Create(options), TraceIdFactory.Create()); services.AddScoped(CreateTraceHeaderContext); services.AddSingleton <IManagedTracerFactory>(tracerFactory); services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); services.AddSingleton(CreateManagedTracer); services.AddSingleton(CreateTraceHeaderPropagatingHandler); services.AddSingleton(traceFallbackPredicate); }
/// <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="setupAction">Action to set up options. Cannot be null.</param> /// <remarks> /// If <see cref="RetryOptions.ExceptionHandling"/> is set to <see cref="ExceptionHandling.Propagate"/> /// and the <see cref="RequestDelegate"/> executed by this middleware throws ad exception and this /// diagnostics library also throws an exception trying to report it and <see cref="AggregateException"/> /// with both exceptions will be thrown. Otherwise only the exception from the <see cref="RequestDelegate"/> /// will be thrown. /// </remarks> public static IServiceCollection AddGoogleTrace( this IServiceCollection services, Action <TraceServiceOptions> setupAction) { GaxPreconditions.CheckNotNull(services, nameof(services)); GaxPreconditions.CheckNotNull(setupAction, nameof(setupAction)); var serviceOptions = new TraceServiceOptions(); setupAction(serviceOptions); var client = serviceOptions.Client ?? TraceServiceClient.Create(); var options = serviceOptions.Options ?? TraceOptions.Create(); var traceFallbackPredicate = serviceOptions.TraceFallbackPredicate ?? TraceDecisionPredicate.Default; var projectId = Project.GetAndCheckProjectId(serviceOptions.ProjectId); var consumer = ManagedTracer.CreateConsumer(client, options); var tracerFactory = ManagedTracer.CreateTracerFactory(projectId, consumer, options); services.AddScoped(CreateTraceHeaderContext); services.AddSingleton(tracerFactory); // Only add the HttpContextAccessor if it's not already added. // This is needed to get the `TraceHeaderContext`. See `CreateTraceHeaderContext`. services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>(); services.AddSingleton(ManagedTracer.CreateDelegatingTracer(() => ContextTracerManager.GetCurrentTracer())); services.AddSingleton(new TraceHeaderPropagatingHandler(() => ContextTracerManager.GetCurrentTracer())); return(services.AddSingleton(traceFallbackPredicate)); }
/// <summary> /// Configures Google Cloud Trace for dependency injection. /// </summary> public static IServiceCollection AddGoogleTrace( this IServiceCollection services, Action <TraceServiceOptions> setupAction) { GaxPreconditions.CheckNotNull(services, nameof(services)); GaxPreconditions.CheckNotNull(setupAction, nameof(setupAction)); var serviceOptions = new TraceServiceOptions(); setupAction(serviceOptions); var client = serviceOptions.Client ?? TraceServiceClient.Create(); var options = serviceOptions.Options ?? TraceOptions.Create(); var projectId = Project.GetAndCheckProjectId(serviceOptions.ProjectId); var consumer = ManagedTracer.CreateConsumer(client, options); var tracerFactory = ManagedTracer.CreateFactory(projectId, consumer, options); services.AddSingleton(tracerFactory); services.AddSingleton(ManagedTracer.CreateDelegatingTracer(ContextTracerManager.GetCurrentTracer)); // On .Net Standard 2.0 or higher, we can use the System.Net.Http.IHttpClientFactory defined in Microsoft.Extensions.Http, // for which we need a DelegatingHandler with no InnerHandler set. This is the recommended way. // It should be registered as follows. return(services.AddTransient(UnchainedTraceHeaderPropagatingHandlerFactory)); }
public SimpleManagedTracerTest() { _testId = IdGenerator.FromDateTime(); _grpcConsumer = new GrpcTraceConsumer(TraceServiceClient.Create()); _startTime = DateTimeOffset.UtcNow; }
public TraceHeaderPropagatingHandlerTest() { _testId = IdGenerator.FromDateTime(); _consumer = new GrpcTraceConsumer(TraceServiceClient.Create()); _tracer = SimpleManagedTracer.Create(_consumer, TestEnvironment.GetTestProjectId(), _traceIdFactory.NextId(), null); _startTime = DateTimeOffset.UtcNow; }
/// <summary> /// Creates a trace consumer for a <see cref="TraceServiceClient"/> and options. /// </summary> /// <param name="client">The trace client. Must not be null.</param> /// <param name="options">Trace options. Must not be null.</param> public static IConsumer <TraceProto> CreateConsumer(TraceServiceClient client, TraceOptions options) { GaxPreconditions.CheckNotNull(client, nameof(client)); GaxPreconditions.CheckNotNull(options, nameof(options)); return(ConsumerFactory <TraceProto> .GetConsumer( new GrpcTraceConsumer(client), MessageSizer <TraceProto> .GetSize, options.BufferOptions, options.RetryOptions)); }
/// <summary> /// Creates a <see cref="SimpleManagedTracer"/> with a <see cref="GrpcTraceConsumer"/>. /// </summary> private SimpleManagedTracer CreateTracer() { string traceId = _traceIdFactory.NextId(); var traceProto = new TraceProto { ProjectId = _projectId, TraceId = traceId }; var consumer = new GrpcTraceConsumer(TraceServiceClient.CreateAsync()); return(SimpleManagedTracer.Create(consumer, traceProto, null)); }
/// <summary>Snippet for ListTracesAsync</summary> public async Task ListTracesRequestObjectAsync() { // Snippet: ListTracesAsync(ListTracesRequest, CallSettings) // Create client TraceServiceClient traceServiceClient = await TraceServiceClient.CreateAsync(); // Initialize request argument(s) ListTracesRequest request = new ListTracesRequest { ProjectId = "", View = ListTracesRequest.Types.ViewType.Unspecified, StartTime = new Timestamp(), EndTime = new Timestamp(), Filter = "", OrderBy = "", }; // Make the request PagedAsyncEnumerable <ListTracesResponse, Trace> response = traceServiceClient.ListTracesAsync(request); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Trace item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListTracesResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Trace item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Trace> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Trace item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for GetTrace</summary> public void GetTrace() { // Snippet: GetTrace(string, string, CallSettings) // Create client TraceServiceClient traceServiceClient = TraceServiceClient.Create(); // Initialize request argument(s) string projectId = ""; string traceId = ""; // Make the request Trace response = traceServiceClient.GetTrace(projectId, traceId); // End snippet }
public async Task ExportAsync(IEnumerable <ISpanData> spanDataList) { TraceServiceClient traceWriter = TraceServiceClient.Create(settings: traceServiceSettings); var batchSpansRequest = new BatchWriteSpansRequest { ProjectName = googleCloudProjectId, Spans = { spanDataList.Select(s => s.ToSpan(googleCloudProjectId.ProjectId)) }, }; await traceWriter.BatchWriteSpansAsync(batchSpansRequest); }
/// <summary>Snippet for PatchTraces</summary> public void PatchTraces() { // Snippet: PatchTraces(string, Traces, CallSettings) // Create client TraceServiceClient traceServiceClient = TraceServiceClient.Create(); // Initialize request argument(s) string projectId = ""; Traces traces = new Traces(); // Make the request traceServiceClient.PatchTraces(projectId, traces); // End snippet }
private CloudTrace(string projectId, TraceOptions options = null, TraceServiceClient client = null, TraceDecisionPredicate traceFallbackPredicate = null) { GaxPreconditions.CheckNotNull(projectId, nameof(projectId)); // Create the default values if not set. client = client ?? TraceServiceClient.Create(); options = options ?? TraceOptions.Create(); _traceFallbackPredicate = traceFallbackPredicate ?? TraceDecisionPredicate.Default; _consumer = ManagedTracer.CreateConsumer(client, options); _tracerFactory = ManagedTracer.CreateTracerFactory(projectId, _consumer, options); }
/// <summary>Snippet for BatchWriteSpans</summary> public void BatchWriteSpans() { // Snippet: BatchWriteSpans(ProjectName,IEnumerable<apis::Span>,CallSettings) // Create client TraceServiceClient traceServiceClient = TraceServiceClient.Create(); // Initialize request argument(s) ProjectName name = new ProjectName("[PROJECT]"); IEnumerable <apis::Span> spans = new List <apis::Span>(); // Make the request traceServiceClient.BatchWriteSpans(name, spans); // End snippet }
/// <summary>Snippet for BatchWriteSpans</summary> public void BatchWriteSpansResourceNames() { // Snippet: BatchWriteSpans(ProjectName, IEnumerable<Span>, CallSettings) // Create client TraceServiceClient traceServiceClient = TraceServiceClient.Create(); // Initialize request argument(s) ProjectName name = ProjectName.FromProject("[PROJECT]"); IEnumerable <Span> spans = new Span[] { new Span(), }; // Make the request traceServiceClient.BatchWriteSpans(name, spans); // End snippet }
/// <summary>Snippet for BatchWriteSpans</summary> public void BatchWriteSpans() { // Snippet: BatchWriteSpans(string, IEnumerable<Span>, CallSettings) // Create client TraceServiceClient traceServiceClient = TraceServiceClient.Create(); // Initialize request argument(s) string name = "projects/[PROJECT]"; IEnumerable <Span> spans = new Span[] { new Span(), }; // Make the request traceServiceClient.BatchWriteSpans(name, spans); // End snippet }
private CloudTrace(string projectId, TraceConfiguration config = null, Task <TraceServiceClient> client = null) { _projectId = GaxPreconditions.CheckNotNull(projectId, nameof(projectId)); // Create the default values if not set. client = client ?? TraceServiceClient.CreateAsync(); config = config ?? TraceConfiguration.Create(); _traceIdfactory = TraceIdFactory.Create(); _bufferingConsumer = BufferingTraceConsumer.Create(new GrpcTraceConsumer(client)); _rateFactory = RateLimitingTraceOptionsFactory.Create(config); _headerFactory = TraceHeaderTraceOptionsFactory.Create(); }
public async Task GetTraceAsync() { // Snippet: GetTraceAsync(string,string,CallSettings) // Additional: GetTraceAsync(string,string,CancellationToken) // Create client TraceServiceClient traceServiceClient = TraceServiceClient.Create(); // Initialize request argument(s) string projectId = ""; string traceId = ""; // Make the request Trace response = await traceServiceClient.GetTraceAsync(projectId, traceId); // End snippet }
public async Task PatchTracesAsync() { // Snippet: PatchTracesAsync(string,Traces,CallSettings) // Additional: PatchTracesAsync(string,Traces,CancellationToken) // Create client TraceServiceClient traceServiceClient = TraceServiceClient.Create(); // Initialize request argument(s) string projectId = ""; Traces traces = new Traces(); // Make the request await traceServiceClient.PatchTracesAsync(projectId, traces); // End snippet }
/// <summary> /// Initialize tracing for this application. /// </summary> /// <param name="application">The Http application.</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.</param> public static void Initialize(HttpApplication application, string projectId = null, TraceConfiguration config = null, TraceServiceClient client = null, TraceDecisionPredicate traceFallbackPredicate = null) { GaxPreconditions.CheckNotNull(application, nameof(application)); projectId = CommonUtils.GetAndCheckProjectId(projectId); CloudTrace trace = new CloudTrace(projectId, config, client, traceFallbackPredicate); // Add event handlers to the application. application.BeginRequest += trace.BeginRequest; application.EndRequest += trace.EndRequest; application.Disposed += (object sender, EventArgs e) => { trace.Dispose(); }; }