public virtual void Emit <TAggregateEvent>(TAggregateEvent aggregateEvent, IMetadata?metadata = null)
where TAggregateEvent : class, IAggregateEvent <TAggregate, TIdentity>
{
var committedEvent = From(aggregateEvent, Version, metadata);
Persist(committedEvent, ApplyCommittedEvent);
}
public MetadataHeadersCollection(IMetadata?headers)
{
if (headers is null)
{
ThrowHelper.ThrowArgumentNullException(nameof(headers));
}
_headers = headers;
}
private static SpanContext?ExtractPropagatedContext(IMetadata?metadata)
{
try
{
if (metadata is not null)
{
return(SpanContextPropagator.Instance.Extract(new MetadataHeadersCollection(metadata)));
}
}
catch (Exception ex)
{
Log.Error(ex, "Error extracting propagated HTTP headers.");
}
return(null);
}
public DataTemplateMetadata([CanBeNull] IMetadata?metadata)
{
if (metadata == null)
{
return;
}
if (metadata.TryGetValue(nameof(DataType), out var viewModel))
{
DataType = viewModel as Type;
}
if (metadata.TryGetValue(nameof(Role), out var role))
{
Role = role;
}
}
protected virtual object FromObject(object aggregateEvent, long version, IMetadata?metadata = null)
{
if (aggregateEvent is IAggregateEvent)
{
_eventDefinitionService.Load(aggregateEvent.GetType());
var eventDefinition = _eventDefinitionService.GetDefinition(aggregateEvent.GetType());
var aggregateSequenceNumber = version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.UtcNow;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
SourceId = PinnedCommand.SourceId,
EventId = eventId,
EventName = eventDefinition.Name,
EventVersion = eventDefinition.Version
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var genericType = typeof(CommittedEvent <, ,>)
.MakeGenericType(typeof(TAggregate), typeof(TIdentity), aggregateEvent.GetType());
var committedEvent = Activator.CreateInstance(
genericType,
Id,
aggregateEvent,
eventMetadata,
now,
aggregateSequenceNumber);
return(committedEvent);
}
throw new InvalidOperationException("could not perform the required mapping for committed event.");
}
public VisualCompositionMetadata(IMetadata?metadata)
{
if (metadata == null)
{
return;
}
if (metadata.TryGetValue(nameof(Role), out var role))
{
Role = role;
}
if (metadata.TryGetValue(nameof(Sequence), out var sequence) && (sequence is double d))
{
Sequence = d;
}
if (metadata.TryGetValue(nameof(TargetRegions), out var targetRegions))
{
TargetRegions = targetRegions as string[];
}
}
public virtual CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent> From <TAggregateEvent>(TAggregateEvent aggregateEvent,
long version, IMetadata?metadata = null)
where TAggregateEvent : class, IAggregateEvent <TAggregateSaga, TIdentity>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
EventDefinitionService.Load(aggregateEvent.GetType());
var eventDefinition = EventDefinitionService.GetDefinition(aggregateEvent.GetType());
var aggregateSequenceNumber = version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.UtcNow;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId,
EventName = eventDefinition.Name,
EventVersion = eventDefinition.Version
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var committedEvent = new CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, aggregateSequenceNumber);
return(committedEvent);
}
public static Scope?CreateServerSpan <TTarget>(Tracer tracer, TTarget target, IMetadata?metadata)
{
var serverHandler = target.DuckCast <ServerCallHandlerStruct>();
var method = serverHandler.Method;
Scope?scope = null;
try
{
var tags = new GrpcServerTags();
// Grpc.Core server tags are typically the root span, so use enabledWithGlobalSetting=true
GrpcCommon.AddGrpcTags(tags, tracer, method.GrpcType, name: method.Name, path: method.FullName, serviceName: method.ServiceName, analyticsEnabledWithGlobalSetting: true);
// If we have a local span (e.g. from aspnetcore) then use that as the parent
// Otherwise, use the distributed context as the parent
var spanContext = tracer.ActiveScope?.Span.Context;
if (spanContext is null)
{
spanContext = ExtractPropagatedContext(metadata);
}
var serviceName = tracer.DefaultServiceName ?? "grpc-server";
scope = tracer.StartActiveInternal(GrpcCommon.OperationName, parent: spanContext, tags: tags, serviceName: serviceName);
var span = scope.Span;
span.Type = SpanTypes.Grpc;
span.ResourceName = method.FullName;
if (metadata?.Count > 0)
{
span.SetHeaderTags(new MetadataHeadersCollection(metadata), tracer.Settings.GrpcTags, GrpcCommon.RequestMetadataTagPrefix);
}
}
catch (Exception ex)
{
Log.Error(ex, "Error creating server span for GRPC call");
}
return(scope);
}
/// <summary>Initializes a new instance of the <see cref="ExportAdapter{T}"/> class.</summary>
/// <param name="valueFactory">The value factory.</param>
/// <param name="metadata">The metadata.</param>
public ExportAdapter([NotNull] Func <T?> valueFactory, [CanBeNull] IMetadata?metadata)
{
_valueFactory = valueFactory;
_metadata = metadata;
}
/// <summary>Initializes a new instance of the <see cref="ExportAdapter{T}"/> class.</summary>
/// <param name="valueFactory">The value factory.</param>
/// <param name="metadata">The metadata.</param>
public ExportAdapter(Func <T?> valueFactory, IMetadata?metadata)
{
_valueFactory = valueFactory;
_metadata = metadata;
}