public static unsafe CEventTrace.SpanId ConvertSpanId(SpanId spanId)
{
var internalSpanId = new CEventTrace.SpanId();
ApiInterop.Memcpy(internalSpanId.Data, spanId.Data, SpanId.SpanIdSize);
return(internalSpanId);
}
public long Write(byte[] data)
{
ThrowIfStreamClosed();
var remainingCapacity = CIO.StreamGetRemainingWriteCapacityBytes(Stream);
if (remainingCapacity < data.Length)
{
throw new NotSupportedException("Not enough stream capacity to write data.");
}
var bytesWritten = 0L;
fixed(byte *dataToWrite = data)
{
bytesWritten = CIO.StreamWrite(Stream, dataToWrite, 1);
}
if (bytesWritten != -1)
{
return(bytesWritten);
}
var rawError = CIO.StreamGetLastError(Stream);
throw new IOException(ApiInterop.FromUtf8Cstr(rawError));
}
// Returns the SpanId of the newly-created Span in the EventTracer
public SpanId AddSpan(SpanId[] causes)
{
unsafe
{
if (causes == null)
{
return(AddSpan());
}
var causeIds = new CEventTrace.SpanId[causes.Length];
for (var i = 0; i < causes.Length; i++)
{
causeIds[i] = ParameterConversion.ConvertSpanId(causes[i]);
}
CEventTrace.SpanId createdSpanId;
fixed(CEventTrace.SpanId *fixedCauseIds = causeIds)
{
createdSpanId = CEventTrace.EventTracerAddSpan(eventTracer, fixedCauseIds, (uint)causeIds.Length);
}
var newSpanId = new SpanId();
ApiInterop.Memcpy(newSpanId.Data, createdSpanId.Data, SpanId.SpanIdSize);
return(newSpanId);
}
}
public static unsafe Item ConvertItem(CEventTrace.Item *itemContainer)
{
var newItem = new Item();
if (itemContainer->ItemType == 0)
{
// The item is newly initialized so return an empty Item
return(newItem);
}
newItem.ItemType = (ItemType)itemContainer->ItemType;
switch (newItem.ItemType)
{
case ItemType.Span:
newItem.Span = new Span();
var newSpan = newItem.Span.Value;
ApiInterop.Memcpy(newSpan.Id.Data, itemContainer->ItemUnion.Span.Id.Data, SpanId.SpanIdSize);
newSpan.Causes = new SpanId[(int)itemContainer->ItemUnion.Span.CauseCount];
for (var i = 0; i < newSpan.Causes.Length; i++)
{
fixed(byte *spanIdDest = newSpan.Causes[i].Data)
{
ApiInterop.Memcpy(spanIdDest, itemContainer->ItemUnion.Span.Causes[i].Data, SpanId.SpanIdSize);
}
}
newItem.Span = newSpan;
break;
case ItemType.Event:
newItem.Event = new Event();
var newEvent = newItem.Event.GetValueOrDefault();
newEvent.Id = new SpanId();
ApiInterop.Memcpy(newEvent.Id.Data, itemContainer->ItemUnion.Event.Id.Data, SpanId.SpanIdSize);
newEvent.UnixTimestampMillis = itemContainer->ItemUnion.Event.UnixTimestampMillis;
newEvent.Type = ApiInterop.FromUtf8Cstr(itemContainer->ItemUnion.Event.Type);
newEvent.Message = ApiInterop.FromUtf8Cstr(itemContainer->ItemUnion.Event.Message);
newEvent.Data = new TraceEventData(itemContainer->ItemUnion.Event.Data);
var fields = newEvent.Data.GetAll();
// Release memory allocated to the underlying event data in the itemContainer
newEvent.Data.EventData.Dispose();
// Add the data to the newly initialized event data struct
newEvent.Data = new TraceEventData(fields);
newItem.Event = newEvent;
break;
default:
throw new NotSupportedException("Invalid Item Type provided.");
}
return(newItem);
}
public static IOStream CreateFileStream(string fileName,
OpenModes openModes = OpenModes.OpenModeRead | OpenModes.OpenModeWrite | OpenModes.OpenModeTruncate)
{
fixed(byte *fileNameBytes = ApiInterop.ToUtf8Cstr(fileName))
{
return(new IOStream(CIO.CreateFileStream(fileNameBytes, (CIO.OpenModes)openModes)));
}
}
private static SpanId GetNullSpanId()
{
var nativeSpanId = new SpanId();
var nullSpanId = CEventTrace.SpanIdNull();
unsafe
{
ApiInterop.Memcpy(nativeSpanId.Data, nullSpanId.Data, SpanIdSize);
}
return(nativeSpanId);
}
public SpanId AddSpan()
{
var newSpanId = new SpanId();
unsafe
{
var createdSpanId = CEventTrace.EventTracerAddSpan(eventTracer, null, 0);
ApiInterop.Memcpy(newSpanId.Data, createdSpanId.Data, SpanId.SpanIdSize);
}
return(newSpanId);
}
public SpanId GetActiveSpanId()
{
var nativeSpanId = CEventTrace.EventTracerGetActiveSpanId(eventTracer);
var spanId = new SpanId();
unsafe
{
ApiInterop.Memcpy(spanId.Data, nativeSpanId.Data, SpanId.SpanIdSize);
}
return(spanId);
}
public SpanId AddSpan(SpanId spanId)
{
var newSpanId = new SpanId();
unsafe
{
var internalSpanId = ParameterConversion.ConvertSpanId(spanId);
var createdSpanId = CEventTrace.EventTracerAddSpan(eventTracer, &internalSpanId, 1);
ApiInterop.Memcpy(newSpanId.Data, createdSpanId.Data, SpanId.SpanIdSize);
}
return(newSpanId);
}
public long Ignore(uint bytesToIgnore)
{
ThrowIfStreamClosed();
var bytesIgnored = CIO.StreamIgnore(Stream, bytesToIgnore);
if (bytesIgnored != -1)
{
return(bytesIgnored);
}
var rawError = CIO.StreamGetLastError(Stream);
throw new IOException(ApiInterop.FromUtf8Cstr(rawError));
}
public static Item DeserializeNextItemFromStream(IOStream stream)
{
unsafe
{
var itemContainer = GetThreadLocalItem();
var itemSize = CEventTrace.GetNextSerializedItemSize(stream.Stream);
var deserializeStatus = CEventTrace.DeserializeItemFromStream(stream.Stream, itemContainer, itemSize);
if (deserializeStatus != 1)
{
var errorMessage = CEventTrace.GetLastError();
throw new IOException(ApiInterop.FromUtf8Cstr(errorMessage));
}
return(ParameterConversion.ConvertItem(itemContainer));
}
}
public static unsafe void ConvertEvent(Event eventToConvert, EventParametersCallback callback)
{
CEventTrace.Event internalEvent = new CEventTrace.Event();
internalEvent.UnixTimestampMillis = eventToConvert.UnixTimestampMillis;
internalEvent.Id = ConvertSpanId(eventToConvert.Id);
if (eventToConvert.Data != null && !eventToConvert.Data.EventData.IsClosed)
{
internalEvent.Data = eventToConvert.Data.EventData.GetUnderlying();
}
fixed(byte *eventType = ApiInterop.ToUtf8Cstr(eventToConvert.Type))
fixed(byte *eventMessage = ApiInterop.ToUtf8Cstr(eventToConvert.Message))
{
internalEvent.Type = eventType;
internalEvent.Message = eventMessage;
callback(internalEvent);
}
}
public void SerializeToStream(IOStream stream)
{
unsafe
{
var serializedItemResult = 0;
ParameterConversion.ConvertItem(this, nativeItem =>
{
var itemSize = CEventTrace.GetSerializedItemSize(nativeItem);
serializedItemResult = CEventTrace.SerializeItemToStream(stream.Stream, nativeItem, itemSize);
});
if (serializedItemResult == 1)
{
return;
}
var errorMessage = CEventTrace.GetLastError();
throw new IOException(ApiInterop.FromUtf8Cstr(errorMessage));
}
}
public long Read(byte[] streamData)
{
ThrowIfStreamClosed();
var bytesToRead = (uint)streamData.Length;
var bytesRead = 0L;
fixed(byte *streamDataPointer = streamData)
{
bytesRead = CIO.StreamRead(Stream, streamDataPointer, bytesToRead);
}
if (bytesRead != -1)
{
return(bytesRead);
}
var rawError = CIO.StreamGetLastError(Stream);
throw new IOException(ApiInterop.FromUtf8Cstr(rawError));
}
public long Peek(uint bytesToPeek, out byte[] streamData)
{
ThrowIfStreamClosed();
streamData = new byte[bytesToPeek];
var bytesPeeked = 0L;
fixed(byte *streamDataPointer = streamData)
{
bytesPeeked = CIO.StreamPeek(Stream, streamDataPointer, bytesToPeek);
}
if (bytesPeeked != -1)
{
return(bytesPeeked);
}
var rawError = CIO.StreamGetLastError(Stream);
throw new IOException(ApiInterop.FromUtf8Cstr(rawError));
}
