Esempio n. 1
0
        public static unsafe void WriteStructured(ref GenericEventDescriptor eventDescriptor, ulong userDataCount, EventDataDescriptor *eventDataPtr)
        {
            try
            {
                //using (var pin = new PinCollection())
                fixed(GenericEventDescriptor *eventDescriptorPtr = &eventDescriptor)
                {
                    var traceEvent = new NativeTypes.FABRIC_ETW_TRACE_EVENT_PAYLOAD()
                    {
                        EventDescriptor         = (IntPtr)eventDescriptorPtr,//pin.AddBlittable(eventDescriptor),
                        EventDataDescriptorList = new NativeTypes.FABRIC_ETW_TRACE_EVENT_DATA_DESCRIPTOR_LIST()
                        {
                            Count = userDataCount,
                            UserDataDescriptor = (IntPtr)eventDataPtr
                        },
                        Reserved = IntPtr.Zero
                    };

                    NativeCommon.WriteManagedStructuredTrace(ref traceEvent);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception during interop structured trace writing: {0}", ex);
                Console.WriteLine("EventId: {0}, UserDataCount {1}", eventDescriptor.EventId, userDataCount);
            }
        }
Esempio n. 2
0
        public void VariantWriteLinuxUnstructured(
            ref GenericEventDescriptor genericEventDescriptor,
            int argCount,
            Variant v0  = default(Variant),
            Variant v1  = default(Variant),
            Variant v2  = default(Variant),
            Variant v3  = default(Variant),
            Variant v4  = default(Variant),
            Variant v5  = default(Variant),
            Variant v6  = default(Variant),
            Variant v7  = default(Variant),
            Variant v8  = default(Variant),
            Variant v9  = default(Variant),
            Variant v10 = default(Variant),
            Variant v11 = default(Variant),
            Variant v12 = default(Variant),
            Variant v13 = default(Variant))
        {
            int    eventId = genericEventDescriptor.EventId;
            string text    = string.Format(
                this.eventDescriptors[eventId].Message, new object[]
                { v0.ToObject(), v1.ToObject(), v2.ToObject(), v3.ToObject(), v4.ToObject(), v5.ToObject(), v6.ToObject(), v7.ToObject(), v8.ToObject(), v9.ToObject(), v10.ToObject(), v11.ToObject(), v12.ToObject(), v13.ToObject() }
                );

            string id             = this.eventDescriptors[eventId].hasId && !string.IsNullOrWhiteSpace(v0.ConvertToString()) ? v0.ConvertToString() : eventId.ToString();
            int    typeFieldIndex = this.eventDescriptors[eventId].typeFieldIndex;
            string type           = this.eventDescriptors[eventId].EventName;

            if (this.eventDescriptors[eventId].typeFieldIndex != -1)
            {
                string typeField = GetTypeFromIndex(typeFieldIndex, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
                if (!string.IsNullOrWhiteSpace(typeField))
                {
                    type = typeField;
                }
            }

            TraceViaNative.WriteUnstructured(FabricEvents.Events.GetEventTaskName((EventTask)genericEventDescriptor.Task), type, id, genericEventDescriptor.Level, text);
        }
Esempio n. 3
0
        public TraceEvent(
            IVariantEventWriter variantEventWriter,
            EventTask taskId,
            ushort eventId,
            string eventName,
            EventLevel level,
            EventOpcode opcode,
            EventChannel channel,
            EventKeywords keywords,
            string format,
            bool hasId,
            ProvisionalMetadataAttribute provisionalAttribute,
            int typeFieldIndex,
            EventExtendedMetadataAttribute extendedMetadataAttribute = null)
        {
            if (string.IsNullOrEmpty(eventName))
            {
                throw new ArgumentException(
                          StringResources.Error_EventNameNullOrEmpty,
                          "eventName");
            }

            // We need to apply a keyword mask to the keyword in order for it to show up
            // in the Windows Event Log. The mask that is applied depends on the channel
            // in which we want the event to show up.
            //
            // TODO: We are currently hard-coding the mask values, but this is not ideal
            // because we have reverse-engineered these values by looking at the header
            // file generated by mc.exe. The algorithm to determine these values is an
            // internal implementation detail of mc.exe. A better alternative would be
            // to get the mask value from the source file generated by mc.exe, instead
            // of hard-coding it as a constant here.
            ulong keywordMask = 0;

            switch (channel)
            {
            case EventChannel.Admin:
                keywordMask = AdminChannelKeywordMask;
                break;

            case EventChannel.Debug:
                keywordMask = DebugChannelKeywordMask;
                break;

            case EventChannel.Operational:
                keywordMask = OperationalChannelKeywordMask;
                break;
            }

            long keywordWithMask;

            unchecked
            {
                keywordWithMask = (long)((ulong)keywords | keywordMask | TestKeyword);
            }

            // We ignore the opcode field for now. Manifest generation does the same.
            this.descriptor = new GenericEventDescriptor(
                eventId,
                version,
                (byte)channel,
                (byte)level,
                0,
                (int)taskId,
                keywordWithMask);

            this.eventName      = eventName;
            this.taskId         = taskId;
            this.level          = level;
            this.filterStates   = new bool[(int)TraceSinkType.Max];
            this.samplingRatio  = 0;
            this.hasId          = hasId;
            this.typeFieldIndex = typeFieldIndex;
            this.format         = format;

            this.taskName =
                typeof(FabricEvents.Tasks).GetFields().Single(f => (EventTask)f.GetRawConstantValue() == taskId).Name;

            this.variantEventWriter = variantEventWriter;

            // By default, provisional feature is disabled during object initialization. This needs to be enabled
            // by calling the Update function.
            this.isProvisionalFeatureEnabled = false;

            this.provisionalData = provisionalAttribute;
            if (this.provisionalData != null)
            {
                this.isProvisionalEvent = true;
                this.provisionalCache   = AgeBasedCache <VariantId, Variant[]> .DefaultInstance;
                this.PopulatePositions();
            }

            for (TraceSinkType sink = 0; sink < TraceSinkType.Max; sink++)
            {
                var status   = TraceConfig.GetEventEnabledStatus(sink, this.level, this.taskId, this.eventName);
                var sampling = TraceConfig.GetEventSamplingRatio(sink, this.level, this.taskId, this.eventName);

                this.UpdateProvisionalFeatureStatus(sink, TraceConfig.GetEventProvisionalFeatureStatus(sink));
                this.UpdateSinkEnabledStatus(sink, status);
                this.UpdateSinkSamplingRatio(sink, sampling);
            }

#if DotNetCoreClrLinux
            // TODO - Following code will be removed once fully transitioned to structured traces in Linux
            this.linuxStructuredTracesEnabled = TraceConfig.GetLinuxStructuredTracesEnabled();
            TraceConfig.OnLinuxStructuredTracesEnabledUpdate += this.UpdateLinuxStructuredTracesEnabled;
#endif

            this.ExtendedMetadata = extendedMetadataAttribute;
        }
Esempio n. 4
0
        public unsafe void VariantWrite(ref GenericEventDescriptor genericEventDescriptor, int argCount,
                                        Variant v1  = default(Variant), Variant v2  = default(Variant), Variant v3  = default(Variant),
                                        Variant v4  = default(Variant), Variant v5  = default(Variant), Variant v6  = default(Variant),
                                        Variant v7  = default(Variant), Variant v8  = default(Variant), Variant v9  = default(Variant),
                                        Variant v10 = default(Variant), Variant v11 = default(Variant), Variant v12 = default(Variant),
                                        Variant v13 = default(Variant), Variant v14 = default(Variant))
        {
            if (argCount == 0)
            {
#if !DotNetCoreClrLinux
                this.WriteEvent(genericEventDescriptor.EventId);
#else
                TraceViaNative.WriteStructured(ref genericEventDescriptor, 0, null);
#endif
                return;
            }

            Tracing.EventData *eventSourceData = stackalloc Tracing.EventData[argCount];
            byte *dataBuffer = stackalloc byte[EventDataArrayBuilder.BasicTypeAllocationBufferSize * argCount];
            var   edb        = new EventDataArrayBuilder(eventSourceData, dataBuffer);

            if (!edb.AddEventDataWithTruncation(argCount, ref v1, ref v2, ref v3, ref v4, ref v5, ref v6, ref v7, ref v8, ref v9, ref v10, ref v11, ref v12, ref v13, ref v14))
            {
                Debug.Fail(string.Format("EventData for eventid {0} is invalid. Check the total size of the event.",
                                         genericEventDescriptor.EventId));
                return;
            }

            fixed(char *s1 = v1.ConvertToString(),
                  s2       = v2.ConvertToString(),
                  s3       = v3.ConvertToString(),
                  s4       = v4.ConvertToString(),
                  s5       = v5.ConvertToString(),
                  s6       = v6.ConvertToString(),
                  s7       = v7.ConvertToString(),
                  s8       = v8.ConvertToString(),
                  s9       = v9.ConvertToString(),
                  s10      = v10.ConvertToString(),
                  s11      = v11.ConvertToString(),
                  s12      = v12.ConvertToString(),
                  s13      = v13.ConvertToString(),
                  s14      = v14.ConvertToString())
            {
                var tracingEventDataPtr = edb.ToEventDataArray(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14);

                // Convert to EventSource.EventData from Tracing.EventData.
#if !DotNetCoreClrLinux
                EventData *eventDataPtr = stackalloc EventData[argCount];
                for (uint i = 0; i < argCount; ++i)
                {
                    eventDataPtr[i].DataPointer = (IntPtr)tracingEventDataPtr[i].DataPointer;
                    eventDataPtr[i].Size        = (int)tracingEventDataPtr[i].Size;
                }

                this.WriteEventCore(genericEventDescriptor.EventId, argCount, eventDataPtr);
#else
                EventDataDescriptor *eventDataPtr = stackalloc EventDataDescriptor[argCount];
                for (uint i = 0; i < argCount; ++i)
                {
                    eventDataPtr[i].DataPointer = (UInt64)tracingEventDataPtr[i].DataPointer;
                    eventDataPtr[i].Size        = tracingEventDataPtr[i].Size;
                }

                TraceViaNative.WriteStructured(ref genericEventDescriptor, (uint)argCount, eventDataPtr);
#endif
            }
        }
        public unsafe void VariantWrite(
            ref GenericEventDescriptor genericEventDescriptor,
            int argCount,
            Variant v0  = default(Variant),
            Variant v1  = default(Variant),
            Variant v2  = default(Variant),
            Variant v3  = default(Variant),
            Variant v4  = default(Variant),
            Variant v5  = default(Variant),
            Variant v6  = default(Variant),
            Variant v7  = default(Variant),
            Variant v8  = default(Variant),
            Variant v9  = default(Variant),
            Variant v10 = default(Variant),
            Variant v11 = default(Variant),
            Variant v12 = default(Variant),
            Variant v13 = default(Variant))
        {
            EventDescriptor eventDesc = new EventDescriptor(genericEventDescriptor.EventId, genericEventDescriptor.Version, genericEventDescriptor.Channel, genericEventDescriptor.Level, genericEventDescriptor.Opcode, genericEventDescriptor.Task, genericEventDescriptor.Keywords);

            if (argCount == 0)
            {
                this.WriteEvent(ref eventDesc, argCount, null);
                return;
            }

            EventData *eventSourceData = stackalloc EventData[argCount]; // allocation for the data descriptors
            byte *     dataBuffer      = stackalloc byte[EventDataArrayBuilder.BasicTypeAllocationBufferSize * argCount];

            // 16 byte for non-string argument
            var edb = new EventDataArrayBuilder(eventSourceData, dataBuffer);

            if (!edb.AddEventDataWithTruncation(argCount, ref v0, ref v1, ref v2, ref v3, ref v4, ref v5, ref v6, ref v7, ref v8, ref v9, ref v10, ref v11, ref v12, ref v13))
            {
                Debug.Fail(string.Format("EventData for eventid {0} is invalid. Check the total size of the event.",
                                         eventDesc.EventId));
                return;
            }

            fixed(
                char *s0 = v0.ConvertToString(),
                s1       = v1.ConvertToString(),
                s2       = v2.ConvertToString(),
                s3       = v3.ConvertToString(),
                s4       = v4.ConvertToString(),
                s5       = v5.ConvertToString(),
                s6       = v6.ConvertToString(),
                s7       = v7.ConvertToString(),
                s8       = v8.ConvertToString(),
                s9       = v9.ConvertToString(),
                s10      = v10.ConvertToString(),
                s11      = v11.ConvertToString(),
                s12      = v12.ConvertToString(),
                s13      = v13.ConvertToString())
            {
                var eventDataPtr = edb.ToEventDataArray(
                    s0,
                    s1,
                    s2,
                    s3,
                    s4,
                    s5,
                    s6,
                    s7,
                    s8,
                    s9,
                    s10,
                    s11,
                    s12,
                    s13);

                this.WriteEvent(ref eventDesc, argCount, (IntPtr)eventDataPtr);
            }
        }