/// <summary> /// Gets a single trace by its ID. /// </summary> /// <param name="request"> /// The request object containing all of the parameters for the API call. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// The RPC response. /// </returns> public override Trace GetTrace( GetTraceRequest request, gaxgrpc::CallSettings callSettings = null) { Modify_GetTraceRequest(ref request, ref callSettings); return(_callGetTrace.Sync(request, callSettings)); }
public async stt::Task GetTraceRequestObjectAsync() { moq::Mock <TraceService.TraceServiceClient> mockGrpcClient = new moq::Mock <TraceService.TraceServiceClient>(moq::MockBehavior.Strict); GetTraceRequest request = new GetTraceRequest { ProjectId = "project_id43ad98b0", TraceId = "trace_id105c890f", }; Trace expectedResponse = new Trace { ProjectId = "project_id43ad98b0", TraceId = "trace_id105c890f", Spans = { new TraceSpan(), }, }; mockGrpcClient.Setup(x => x.GetTraceAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Trace>(stt::Task.FromResult(expectedResponse), null, null, null, null)); TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null); Trace responseCallSettings = await client.GetTraceAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); xunit::Assert.Same(expectedResponse, responseCallSettings); Trace responseCancellationToken = await client.GetTraceAsync(request, st::CancellationToken.None); xunit::Assert.Same(expectedResponse, responseCancellationToken); mockGrpcClient.VerifyAll(); }
public override async Task GetTrace(GetTraceRequest request, IServerStreamWriter <SpansResponseChunk> responseStream, ServerCallContext context) { var traceId = _Mapper.Map <string>(request.TraceId); _Logger.Log(LogLevel.Information, "GrpcQuery.GetTrace.{0}", traceId); var result = await _TracingQuery.GetTracing(traceId, context.CancellationToken); SpansResponseChunk response = new SpansResponseChunk(); var process = result.Processes; List <Jaeger.ApiV2.Span> spans = new List <Span>(); foreach (var spanModel in result.Spans) { var span = _Mapper.Map <Span>(spanModel); if (!string.IsNullOrEmpty(spanModel.ProcessId) && process.TryGetValue(spanModel.ProcessId, out var spanProcess) && spanProcess != null) { span.Process = _Mapper.Map <Jaeger.ApiV2.Process>(spanProcess); } spans.Add(span); } var repeatedField_span = new RepeatedField <Span>(); repeatedField_span.AddRange(spans); response.Spans.Add(_Mapper.Map <RepeatedField <Span> >(repeatedField_span)); await responseStream.WriteAsync(response); }
/// <summary> /// Gets a single trace by its ID. /// </summary> /// <param name="request"> /// The request object containing all of the parameters for the API call. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// A Task containing the RPC response. /// </returns> public override stt::Task <Trace> GetTraceAsync( GetTraceRequest request, gaxgrpc::CallSettings callSettings = null) { Modify_GetTraceRequest(ref request, ref callSettings); return(_callGetTrace.Async(request, callSettings)); }
/// <summary> /// Get the trace details identified by traceId /// /// </summary> /// <param name="request">The request object containing the details to send. Required.</param> /// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param> /// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param> /// <returns>A response object containing details about the completed operation</returns> /// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/apmtraces/GetTrace.cs.html">here</a> to see an example of how to use GetTrace API.</example> public async Task <GetTraceResponse> GetTrace(GetTraceRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default) { logger.Trace("Called getTrace"); Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/traces/{traceKey}".Trim('/'))); HttpMethod method = new HttpMethod("GET"); HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request); requestMessage.Headers.Add("Accept", "application/json"); GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration); HttpResponseMessage responseMessage; try { if (retryingClient != null) { responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false); } else { responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false); } this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage); return(Converter.FromHttpResponseMessage <GetTraceResponse>(responseMessage)); } catch (Exception e) { logger.Error($"GetTrace failed with error: {e.Message}"); throw; } }
/// <summary> /// Gets a single trace by its ID. /// </summary> /// <param name="projectId"> /// ID of the Cloud project where the trace data is stored. /// </param> /// <param name="traceId"> /// ID of the trace to return. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// The RPC response. /// </returns> public override Trace GetTrace( string projectId, string traceId, CallSettings callSettings = null) { GetTraceRequest request = new GetTraceRequest { ProjectId = projectId, TraceId = traceId, }; Modify_GetTraceRequest(ref request, ref callSettings); return(_callGetTrace.Sync(request, callSettings)); }
/// <summary>Snippet for GetTrace</summary> public void GetTraceRequestObject() { // Snippet: GetTrace(GetTraceRequest, CallSettings) // Create client TraceServiceClient traceServiceClient = TraceServiceClient.Create(); // Initialize request argument(s) GetTraceRequest request = new GetTraceRequest { ProjectId = "", TraceId = "", }; // Make the request Trace response = traceServiceClient.GetTrace(request); // End snippet }
public async Task GetTraceAsync_RequestObject() { // Snippet: GetTraceAsync(GetTraceRequest,CallSettings) // Create client TraceServiceClient traceServiceClient = await TraceServiceClient.CreateAsync(); // Initialize request argument(s) GetTraceRequest request = new GetTraceRequest { ProjectId = "", TraceId = "", }; // Make the request Trace response = await traceServiceClient.GetTraceAsync(request); // End snippet }
public void GetTrace() { moq::Mock <TraceService.TraceServiceClient> mockGrpcClient = new moq::Mock <TraceService.TraceServiceClient>(moq::MockBehavior.Strict); GetTraceRequest request = new GetTraceRequest { ProjectId = "project_id43ad98b0", TraceId = "trace_id105c890f", }; Trace expectedResponse = new Trace { ProjectId = "project_id43ad98b0", TraceId = "trace_id105c890f", Spans = { new TraceSpan(), }, }; mockGrpcClient.Setup(x => x.GetTrace(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse); TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null); Trace response = client.GetTrace(request.ProjectId, request.TraceId); xunit::Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public async Task GetTraceAsync2() { Mock <TraceService.TraceServiceClient> mockGrpcClient = new Mock <TraceService.TraceServiceClient>(MockBehavior.Strict); GetTraceRequest request = new GetTraceRequest { ProjectId = "projectId-1969970175", TraceId = "traceId1270300245", }; Trace expectedResponse = new Trace { ProjectId = "projectId2939242356", TraceId = "traceId2987826376", }; mockGrpcClient.Setup(x => x.GetTraceAsync(request, It.IsAny <CallOptions>())) .Returns(new Grpc.Core.AsyncUnaryCall <Trace>(Task.FromResult(expectedResponse), null, null, null, null)); TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null); Trace response = await client.GetTraceAsync(request); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public void GetTrace2() { Mock <TraceService.TraceServiceClient> mockGrpcClient = new Mock <TraceService.TraceServiceClient>(MockBehavior.Strict); GetTraceRequest request = new GetTraceRequest { ProjectId = "projectId-1969970175", TraceId = "traceId1270300245", }; Trace expectedResponse = new Trace { ProjectId = "projectId2939242356", TraceId = "traceId2987826376", }; mockGrpcClient.Setup(x => x.GetTrace(request, It.IsAny <CallOptions>())) .Returns(expectedResponse); TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null); Trace response = client.GetTrace(request); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
protected override void ProcessRecord() { base.ProcessRecord(); GetTraceRequest request; try { request = new GetTraceRequest { ApmDomainId = ApmDomainId, TraceKey = TraceKey, OpcRequestId = OpcRequestId }; response = client.GetTrace(request).GetAwaiter().GetResult(); WriteOutput(response, response.Trace); FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
partial void Modify_GetTraceRequest(ref GetTraceRequest request, ref gaxgrpc::CallSettings settings);
/// <summary> /// Gets a single trace by its ID. /// </summary> /// <param name="request"> /// The request object containing all of the parameters for the API call. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// The RPC response. /// </returns> public virtual Trace GetTrace( GetTraceRequest request, gaxgrpc::CallSettings callSettings = null) { throw new sys::NotImplementedException(); }
/// <summary> /// Gets a single trace by its ID. /// </summary> /// <param name="request"> /// The request object containing all of the parameters for the API call. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// A Task containing the RPC response. /// </returns> public virtual stt::Task <Trace> GetTraceAsync( GetTraceRequest request, gaxgrpc::CallSettings callSettings = null) { throw new sys::NotImplementedException(); }
/// <summary> /// Gets a single trace by its ID. /// </summary> /// <param name="request"> /// The request object containing all of the parameters for the API call. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// A Task containing the RPC response. /// </returns> public virtual Task <Trace> GetTraceAsync( GetTraceRequest request, CallSettings callSettings = null) { throw new NotImplementedException(); }
/// <summary> /// Gets a single trace by its ID. /// </summary> /// <param name="request"> /// The request object containing all of the parameters for the API call. /// </param> /// <param name="cancellationToken"> /// A <see cref="st::CancellationToken"/> to use for this RPC. /// </param> /// <returns> /// A Task containing the RPC response. /// </returns> public virtual stt::Task <Trace> GetTraceAsync( GetTraceRequest request, st::CancellationToken cancellationToken) => GetTraceAsync( request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken));
public override Task GetTrace(GetTraceRequest request, IServerStreamWriter <SpansResponseChunk> responseStream, ServerCallContext context) { return(base.GetTrace(request, responseStream, context)); }