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