private Dictionary <string, string> ExtractContextProperties(IServiceRemotingRequestMessage message)
{
IServiceRemotingRequestMessageHeader headers = message.GetHeader();
//DANGER!!! this is using reflection to get to internal dictionary of headers collection.
if (getHeadersField == null)
{
getHeadersField = headers.GetType()
.GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
.First(f => f.Name == "headers");
}
var headersCollection = getHeadersField.GetValue(headers) as Dictionary <string, byte[]>;
if (headersCollection == null)
{
return(null);
}
var result = headersCollection.ToDictionary(
e => e.Key,
e => e.Value == null ? null : Enc.GetString(e.Value));
// ActivityId becomes parent here
if (result.TryGetValue(KnownProperty.ActivityId, out string activityId))
{
result[KnownProperty.ParentActivityId] = activityId;
result.Remove(KnownProperty.ActivityId);
}
return(result);
}
private static void InjectContext(PropagationContext context, IServiceRemotingRequestMessageHeader messageHeaders)
{
if (context.TraceId == 0 || context.ParentSpanId == 0)
{
return;
}
try
{
messageHeaders.TryAddHeader(HttpHeaderNames.TraceId, context, ctx => BitConverter.GetBytes(ctx.TraceId));
messageHeaders.TryAddHeader(HttpHeaderNames.ParentId, context, ctx => BitConverter.GetBytes(ctx.ParentSpanId));
if (context.SamplingPriority != null)
{
messageHeaders.TryAddHeader(HttpHeaderNames.SamplingPriority, context, ctx => BitConverter.GetBytes((int)ctx.SamplingPriority !));
}
if (!string.IsNullOrEmpty(context.Origin))
{
messageHeaders.TryAddHeader(HttpHeaderNames.Origin, context, ctx => Encoding.UTF8.GetBytes(ctx.Origin !));
}
}
catch (Exception ex)
{
Log.Error(ex, "Error injecting message headers.");
}
}
private Task <IServiceRemotingResponseMessage> OnDispatch(
IServiceRemotingRequestMessageHeader requestMessageHeaders,
IServiceRemotingRequestMessageBody requestBody, CancellationToken cancellationToken)
{
MethodDispatcherBase methodDispatcher;
if (!this.methodDispatcherMap.TryGetValue(requestMessageHeaders.InterfaceId, out methodDispatcher))
{
throw new NotImplementedException(string.Format(CultureInfo.CurrentCulture,
SR.ErrorInterfaceNotImplemented, requestMessageHeaders.InterfaceId, this.serviceImplementation));
}
Task <IServiceRemotingResponseMessageBody> dispatchTask = null;
var stopwatch = Stopwatch.StartNew();
try
{
dispatchTask = methodDispatcher.DispatchAsync(this.serviceImplementation,
requestMessageHeaders.MethodId,
requestBody,
this.GetRemotingMessageBodyFactory(),
cancellationToken);
}
catch (Exception e)
{
var info = ExceptionDispatchInfo.Capture(e);
this.servicePerformanceCounterProvider.OnServiceMethodFinish
(requestMessageHeaders.InterfaceId,
requestMessageHeaders.MethodId,
stopwatch.Elapsed, e);
info.Throw();
}
return(dispatchTask.ContinueWith(
t =>
{
object responseBody = null;
try
{
responseBody = t.GetAwaiter().GetResult();
}
catch (Exception e)
{
var info = ExceptionDispatchInfo.Capture(e);
this.servicePerformanceCounterProvider.OnServiceMethodFinish
(requestMessageHeaders.InterfaceId,
requestMessageHeaders.MethodId,
stopwatch.Elapsed, e);
info.Throw();
}
this.servicePerformanceCounterProvider.OnServiceMethodFinish(
requestMessageHeaders.InterfaceId,
requestMessageHeaders.MethodId,
stopwatch.Elapsed);
return (IServiceRemotingResponseMessage) new ServiceRemotingResponseMessage(null,
(IServiceRemotingResponseMessageBody)responseBody);
},
TaskContinuationOptions.ExecuteSynchronously));
}
private static IEnumerable <string?> GetHeaders(IServiceRemotingRequestMessageHeader headers, string headerName)
{
if (headers.TryGetHeaderValueString(headerName, out var headerValue))
{
yield return(headerValue);
}
}
public override async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessage requestMessage)
{
IServiceRemotingRequestMessageHeader headers = requestMessage.GetHeader();
if (headers.TryGetHeaderValue(ActivityServiceRemoting.OperationIdHeaderName, out byte[] operationIdBytes))
private static PropagationContext?ExtractContext(IServiceRemotingRequestMessageHeader messageHeaders)
{
try
{
ulong traceId = messageHeaders.TryGetHeaderValueUInt64(HttpHeaderNames.TraceId) ?? 0;
if (traceId > 0)
{
ulong parentSpanId = messageHeaders.TryGetHeaderValueUInt64(HttpHeaderNames.ParentId) ?? 0;
if (parentSpanId > 0)
{
SamplingPriority?samplingPriority = (SamplingPriority?)messageHeaders.TryGetHeaderValueInt32(HttpHeaderNames.SamplingPriority);
string? origin = messageHeaders.TryGetHeaderValueString(HttpHeaderNames.Origin);
return(new PropagationContext(traceId, parentSpanId, samplingPriority, origin));
}
}
return(null);
}
catch (Exception ex)
{
Log.Error(ex, "Error extracting message headers.");
return(default);
public static string?TryGetHeaderValueString(this IServiceRemotingRequestMessageHeader headers, string headerName)
{
if (headers.TryGetHeaderValue(headerName, out var bytes) && bytes is not null)
{
return(Encoding.UTF8.GetString(bytes));
}
return(null);
}
/// <summary>
/// Extract activity information from incoming remoting request headers
/// </summary>
public static void ExtractActivityFromIncomingRequest(this IServiceRemotingRequestMessage requestMessage, Activity?activity)
{
if (activity == null)
{
return;
}
IServiceRemotingRequestMessageHeader headers = requestMessage.GetHeader();
if (headers.TryGetHeaderValue(TraceParentHeaderName, out byte[] idBytes))
private static void ExtractAndSetAllCorrelationHeaderValues(IServiceRemotingRequestMessageHeader header)
{
foreach (var headerName in Constants.ExecutionTree.All)
{
if (header.TryGetHeaderValue(headerName, out var headerValue))
{
DecodeHeaderAndSetCallContext(headerName, headerValue);
}
}
}
internal static void FromRemotingMessageHeader(IServiceRemotingRequestMessageHeader header)
{
foreach (var customHeader in header.GetCustomHeaders().Where(h => h.Key != CustomHeaders.ReservedHeaderServiceUri))
{
if (customHeader.Key != null)
{
SetData(customHeader.Key, customHeader.Value);
}
}
}
/// <summary>
/// Attach activity information to outgoing remoting request headers
/// </summary>
public static void AttachActivityToOutgoingRequest(this IServiceRemotingRequestMessage requestMessage, Activity?activity)
{
if (activity == null || string.IsNullOrWhiteSpace(activity.Id))
{
return;
}
IServiceRemotingRequestMessageHeader header = requestMessage.GetHeader();
if (!header.TryGetHeaderValue(TraceParentHeaderName, out byte[] _)) // header update not supported
public static bool TryAddHeader(this IServiceRemotingRequestMessageHeader headers, string headerName, PropagationContext context, Func <PropagationContext, byte[]> headerValue)
{
if (!headers.TryGetHeaderValue(headerName, out _))
{
byte[] bytes = headerValue(context);
headers.AddHeader(headerName, bytes);
return(true);
}
return(false);
}
public static bool TryAddHeader(this IServiceRemotingRequestMessageHeader headers, string headerName, string headerValue)
{
if (!headers.TryGetHeaderValue(headerName, out _))
{
byte[] bytes = Encoding.UTF8.GetBytes(headerValue);
headers.AddHeader(headerName, bytes);
return(true);
}
return(false);
}
public static bool TryGetHeaderValueString(this IServiceRemotingRequestMessageHeader headers, string headerName, out string?headerValue)
{
if (headers.TryGetHeaderValue(headerName, out var bytes) && bytes is not null)
{
headerValue = Encoding.UTF8.GetString(bytes);
return(true);
}
headerValue = default;
return(false);
}
/// <summary>
/// Attach activity information to outgoing remoting request headers
/// </summary>
public static void AttachActivityToOutgoingRequest(this IServiceRemotingRequestMessage requestMessage, Activity?activity)
{
if (activity == null)
{
return;
}
IServiceRemotingRequestMessageHeader header = requestMessage.GetHeader();
header.AddHeader(TraceParentHeaderName, s_encoding.GetBytes(activity.Id));
header.AddHeader(TraceStateHeaderName, SerializeBaggage(activity.Baggage.ToArray()));
}
internal bool IsCancellationRequest(IServiceRemotingRequestMessageHeader requestMessageHeaders)
{
byte[] headerValue;
if (requestMessageHeaders.InvocationId != null &&
requestMessageHeaders.TryGetHeaderValue(ServiceRemotingRequestMessageHeader.CancellationHeaderName,
out headerValue))
{
return(true);
}
return(false);
}
private async Task <IServiceRemotingResponseMessageBody> HandleRequestResponseAsync(
IServiceRemotingRequestMessageHeader remotingRequestMessageHeader,
IServiceRemotingRequestMessageBody requestMessageBody,
CancellationToken cancellationToken)
{
IServiceRemotingResponseMessage retval = await this.OnDispatch(remotingRequestMessageHeader, requestMessageBody,
cancellationToken);
if (retval != null)
{
return(retval.GetBody());
}
return(null);
}
public void Enrich(IServiceRemotingRequestMessage message)
{
Dictionary <string, string> context = L.GetContextValues();
if (context.Count == 0)
{
return;
}
IServiceRemotingRequestMessageHeader headers = message.GetHeader();
foreach (KeyValuePair <string, string> cv in context)
{
AddHeader(headers, cv);
}
}
public static IServiceRemotingRequestMessage ProcessRequest(IServiceRemotingRequestMessage requestMessage)
{
if (requestMessage == null)
{
throw new ArgumentNullException(nameof(requestMessage));
}
IServiceRemotingRequestMessageHeader requestMessageHeader = requestMessage.GetHeader();
if (requestMessageHeader == null)
{
return(requestMessage);
}
// Retrieve the tracking context from the message header, if it exists.
if (requestMessageHeader.TryGetHeaderValue(TrackingContext.FullName, out byte[] byteArray))
public IMessageHeader SerializeRequestHeader(IServiceRemotingRequestMessageHeader serviceRemotingRequestMessageHeader)
{
if (serviceRemotingRequestMessageHeader == null)
{
return(null);
}
using (var stream = new SegmentedPoolMemoryStream(this.bufferPoolManager))
{
using (var writer = XmlDictionaryWriter.CreateBinaryWriter(stream))
{
this.requestHeaderSerializer.WriteObject(writer, serviceRemotingRequestMessageHeader);
writer.Flush();
return(new OutgoingMessageHeader(stream.GetBuffers()));
}
}
}
public IMessageHeader SerializeRequestHeader(IServiceRemotingRequestMessageHeader serviceRemotingRequestMessageHeader)
{
if (serviceRemotingRequestMessageHeader == null)
{
return(null);
}
using (var stream = new MemoryStream())
{
using (var writer = XmlDictionaryWriter.CreateBinaryWriter(stream))
{
this.requestHeaderSerializer.WriteObject(writer, serviceRemotingRequestMessageHeader);
writer.Flush();
var buffer = stream.ToArray();
return(new OutgoingMessageHeader(new ArraySegment <byte>(buffer)));
}
}
}
private async Task <IServiceRemotingResponseMessage> HandleSubscriptionRequestsAsync(
IServiceRemotingRequestContext requestContext,
IServiceRemotingRequestMessageHeader messageHeaders,
IServiceRemotingRequestMessageBody requestMsgBody)
{
var actorHeaders = (IActorRemotingMessageHeaders)messageHeaders;
if (actorHeaders.MethodId == Runtime.ActorEventSubscription.SubscribeMethodId)
{
var castedRequestMsgBody =
(EventSubscriptionRequestBody)requestMsgBody.GetParameter(0, "Value",
typeof(EventSubscriptionRequestBody));
await this.actorService.ActorManager
.SubscribeAsync(
actorHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
new ActorEventSubscriberProxy(
castedRequestMsgBody.subscriptionId,
requestContext.GetCallBackClient()));
return(null);
}
if (messageHeaders.MethodId == Runtime.ActorEventSubscription.UnSubscribeMethodId)
{
var castedRequestMsgBody =
(Actors.Remoting.EventSubscriptionRequestBody)requestMsgBody.GetParameter(0, "Value",
typeof(Actors.Remoting.EventSubscriptionRequestBody));
await this.actorService.ActorManager
.UnsubscribeAsync(
actorHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
castedRequestMsgBody.subscriptionId);
return(null);
}
throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, SR.ErrorInvalidMethodId,
messageHeaders.MethodId));
}
private Dictionary <string, string> ExtractContextProperties(IServiceRemotingRequestMessage message)
{
IServiceRemotingRequestMessageHeader headers = message.GetHeader();
//DANGER!!! this is using reflection to get to internal dictionary of headers collection.
if (getHeadersField == null)
{
getHeadersField = headers.GetType()
.GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
.First(f => f.Name == "headers");
}
var headersCollection = getHeadersField.GetValue(headers) as Dictionary <string, byte[]>;
if (headersCollection == null)
{
return(null);
}
return(headersCollection.ToDictionary(
e => e.Key,
e => e.Value == null ? null : Enc.GetString(e.Value)));
}
internal static CustomHeaders GetCustomHeaders(this IServiceRemotingRequestMessageHeader header)
{
var customHeaders = new CustomHeaders();
if (header.TryGetHeaderValue(CustomHeaders.CustomHeader, out byte[] headerValue))
public static int?TryGetHeaderValueInt32(this IServiceRemotingRequestMessageHeader headers, string headerName)
{
if (headers.TryGetHeaderValue(headerName, out byte[] bytes) && bytes?.Length == sizeof(int))
public static string GetMethodName(IServiceRemotingRequestMessage message)
{
IServiceRemotingRequestMessageHeader header = message.GetHeader();
return(GetMethodName(header.InterfaceId, header.MethodId));
}
internal static bool TryGetHeaderValue(this IServiceRemotingRequestMessageHeader messageHeaders, string headerName, out string headerValue)
{
headerValue = null;
if (!messageHeaders.TryGetHeaderValue(headerName, out byte[] headerValueBytes))
internal static void AddHeader(this IServiceRemotingRequestMessageHeader messageHeaders, string headerName, string value)
{
messageHeaders.AddHeader(headerName, Encoding.UTF8.GetBytes(value));
}
private static void AddHeader(IServiceRemotingRequestMessageHeader headers, KeyValuePair <string, string> header)
{
//don't add a header if it already exists
//todo: figure out why it already exists
if (headers.TryGetHeaderValue(header.Key, out byte[] headerValue))
public ServiceRemotingRequestMessage(IServiceRemotingRequestMessageHeader header, IServiceRemotingRequestMessageBody msgBody)
{
this.header = header;
this.msgBody = msgBody;
}
