/// <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));
}
