| package etw |
| |
| import ( |
| "fmt" |
| "math" |
| "reflect" |
| "syscall" |
| "time" |
| "unsafe" |
| ) |
| |
| // FieldOpt defines the option function type that can be passed to |
| // Provider.WriteEvent to add fields to the event. |
| type FieldOpt func(em *eventMetadata, ed *eventData) |
| |
| // WithFields returns the variadic arguments as a single slice. |
| func WithFields(opts ...FieldOpt) []FieldOpt { |
| return opts |
| } |
| |
| // BoolField adds a single bool field to the event. |
| func BoolField(name string, value bool) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeUint8, outTypeBoolean, 0) |
| bool8 := uint8(0) |
| if value { |
| bool8 = uint8(1) |
| } |
| ed.writeUint8(bool8) |
| } |
| } |
| |
| // BoolArray adds an array of bool to the event. |
| func BoolArray(name string, values []bool) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeUint8, outTypeBoolean, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| bool8 := uint8(0) |
| if v { |
| bool8 = uint8(1) |
| } |
| ed.writeUint8(bool8) |
| } |
| } |
| } |
| |
| // StringField adds a single string field to the event. |
| func StringField(name string, value string) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeANSIString, outTypeUTF8, 0) |
| ed.writeString(value) |
| } |
| } |
| |
| // StringArray adds an array of string to the event. |
| func StringArray(name string, values []string) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeANSIString, outTypeUTF8, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeString(v) |
| } |
| } |
| } |
| |
| // IntField adds a single int field to the event. |
| func IntField(name string, value int) FieldOpt { |
| switch unsafe.Sizeof(value) { |
| case 4: |
| return Int32Field(name, int32(value)) |
| case 8: |
| return Int64Field(name, int64(value)) |
| default: |
| panic("Unsupported int size") |
| } |
| } |
| |
| // IntArray adds an array of int to the event. |
| func IntArray(name string, values []int) FieldOpt { |
| inType := inTypeNull |
| var writeItem func(*eventData, int) |
| switch unsafe.Sizeof(values[0]) { |
| case 4: |
| inType = inTypeInt32 |
| writeItem = func(ed *eventData, item int) { ed.writeInt32(int32(item)) } |
| case 8: |
| inType = inTypeInt64 |
| writeItem = func(ed *eventData, item int) { ed.writeInt64(int64(item)) } |
| default: |
| panic("Unsupported int size") |
| } |
| |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inType, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| writeItem(ed, v) |
| } |
| } |
| } |
| |
| // Int8Field adds a single int8 field to the event. |
| func Int8Field(name string, value int8) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeInt8, outTypeDefault, 0) |
| ed.writeInt8(value) |
| } |
| } |
| |
| // Int8Array adds an array of int8 to the event. |
| func Int8Array(name string, values []int8) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeInt8, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeInt8(v) |
| } |
| } |
| } |
| |
| // Int16Field adds a single int16 field to the event. |
| func Int16Field(name string, value int16) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeInt16, outTypeDefault, 0) |
| ed.writeInt16(value) |
| } |
| } |
| |
| // Int16Array adds an array of int16 to the event. |
| func Int16Array(name string, values []int16) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeInt16, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeInt16(v) |
| } |
| } |
| } |
| |
| // Int32Field adds a single int32 field to the event. |
| func Int32Field(name string, value int32) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeInt32, outTypeDefault, 0) |
| ed.writeInt32(value) |
| } |
| } |
| |
| // Int32Array adds an array of int32 to the event. |
| func Int32Array(name string, values []int32) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeInt32, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeInt32(v) |
| } |
| } |
| } |
| |
| // Int64Field adds a single int64 field to the event. |
| func Int64Field(name string, value int64) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeInt64, outTypeDefault, 0) |
| ed.writeInt64(value) |
| } |
| } |
| |
| // Int64Array adds an array of int64 to the event. |
| func Int64Array(name string, values []int64) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeInt64, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeInt64(v) |
| } |
| } |
| } |
| |
| // UintField adds a single uint field to the event. |
| func UintField(name string, value uint) FieldOpt { |
| switch unsafe.Sizeof(value) { |
| case 4: |
| return Uint32Field(name, uint32(value)) |
| case 8: |
| return Uint64Field(name, uint64(value)) |
| default: |
| panic("Unsupported uint size") |
| } |
| } |
| |
| // UintArray adds an array of uint to the event. |
| func UintArray(name string, values []uint) FieldOpt { |
| inType := inTypeNull |
| var writeItem func(*eventData, uint) |
| switch unsafe.Sizeof(values[0]) { |
| case 4: |
| inType = inTypeUint32 |
| writeItem = func(ed *eventData, item uint) { ed.writeUint32(uint32(item)) } |
| case 8: |
| inType = inTypeUint64 |
| writeItem = func(ed *eventData, item uint) { ed.writeUint64(uint64(item)) } |
| default: |
| panic("Unsupported uint size") |
| } |
| |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inType, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| writeItem(ed, v) |
| } |
| } |
| } |
| |
| // Uint8Field adds a single uint8 field to the event. |
| func Uint8Field(name string, value uint8) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeUint8, outTypeDefault, 0) |
| ed.writeUint8(value) |
| } |
| } |
| |
| // Uint8Array adds an array of uint8 to the event. |
| func Uint8Array(name string, values []uint8) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeUint8, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeUint8(v) |
| } |
| } |
| } |
| |
| // Uint16Field adds a single uint16 field to the event. |
| func Uint16Field(name string, value uint16) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeUint16, outTypeDefault, 0) |
| ed.writeUint16(value) |
| } |
| } |
| |
| // Uint16Array adds an array of uint16 to the event. |
| func Uint16Array(name string, values []uint16) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeUint16, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeUint16(v) |
| } |
| } |
| } |
| |
| // Uint32Field adds a single uint32 field to the event. |
| func Uint32Field(name string, value uint32) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeUint32, outTypeDefault, 0) |
| ed.writeUint32(value) |
| } |
| } |
| |
| // Uint32Array adds an array of uint32 to the event. |
| func Uint32Array(name string, values []uint32) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeUint32, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeUint32(v) |
| } |
| } |
| } |
| |
| // Uint64Field adds a single uint64 field to the event. |
| func Uint64Field(name string, value uint64) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeUint64, outTypeDefault, 0) |
| ed.writeUint64(value) |
| } |
| } |
| |
| // Uint64Array adds an array of uint64 to the event. |
| func Uint64Array(name string, values []uint64) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeUint64, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeUint64(v) |
| } |
| } |
| } |
| |
| // UintptrField adds a single uintptr field to the event. |
| func UintptrField(name string, value uintptr) FieldOpt { |
| inType := inTypeNull |
| var writeItem func(*eventData, uintptr) |
| switch unsafe.Sizeof(value) { |
| case 4: |
| inType = inTypeHexInt32 |
| writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) } |
| case 8: |
| inType = inTypeHexInt64 |
| writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) } |
| default: |
| panic("Unsupported uintptr size") |
| } |
| |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inType, outTypeDefault, 0) |
| writeItem(ed, value) |
| } |
| } |
| |
| // UintptrArray adds an array of uintptr to the event. |
| func UintptrArray(name string, values []uintptr) FieldOpt { |
| inType := inTypeNull |
| var writeItem func(*eventData, uintptr) |
| switch unsafe.Sizeof(values[0]) { |
| case 4: |
| inType = inTypeHexInt32 |
| writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) } |
| case 8: |
| inType = inTypeHexInt64 |
| writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) } |
| default: |
| panic("Unsupported uintptr size") |
| } |
| |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inType, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| writeItem(ed, v) |
| } |
| } |
| } |
| |
| // Float32Field adds a single float32 field to the event. |
| func Float32Field(name string, value float32) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeFloat, outTypeDefault, 0) |
| ed.writeUint32(math.Float32bits(value)) |
| } |
| } |
| |
| // Float32Array adds an array of float32 to the event. |
| func Float32Array(name string, values []float32) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeFloat, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeUint32(math.Float32bits(v)) |
| } |
| } |
| } |
| |
| // Float64Field adds a single float64 field to the event. |
| func Float64Field(name string, value float64) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeDouble, outTypeDefault, 0) |
| ed.writeUint64(math.Float64bits(value)) |
| } |
| } |
| |
| // Float64Array adds an array of float64 to the event. |
| func Float64Array(name string, values []float64) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeArray(name, inTypeDouble, outTypeDefault, 0) |
| ed.writeUint16(uint16(len(values))) |
| for _, v := range values { |
| ed.writeUint64(math.Float64bits(v)) |
| } |
| } |
| } |
| |
| // Struct adds a nested struct to the event, the FieldOpts in the opts argument |
| // are used to specify the fields of the struct. |
| func Struct(name string, opts ...FieldOpt) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeStruct(name, uint8(len(opts)), 0) |
| for _, opt := range opts { |
| opt(em, ed) |
| } |
| } |
| } |
| |
| // Time adds a time to the event. |
| func Time(name string, value time.Time) FieldOpt { |
| return func(em *eventMetadata, ed *eventData) { |
| em.writeField(name, inTypeFileTime, outTypeDateTimeUTC, 0) |
| ed.writeFiletime(syscall.NsecToFiletime(value.UTC().UnixNano())) |
| } |
| } |
| |
| // Currently, we support logging basic builtin types (int, string, etc), slices |
| // of basic builtin types, error, types derived from the basic types (e.g. "type |
| // foo int"), and structs (recursively logging their fields). We do not support |
| // slices of derived types (e.g. "[]foo"). |
| // |
| // For types that we don't support, the value is formatted via fmt.Sprint, and |
| // we also log a message that the type is unsupported along with the formatted |
| // type. The intent of this is to make it easier to see which types are not |
| // supported in traces, so we can evaluate adding support for more types in the |
| // future. |
| func SmartField(name string, v interface{}) FieldOpt { |
| switch v := v.(type) { |
| case bool: |
| return BoolField(name, v) |
| case []bool: |
| return BoolArray(name, v) |
| case string: |
| return StringField(name, v) |
| case []string: |
| return StringArray(name, v) |
| case int: |
| return IntField(name, v) |
| case []int: |
| return IntArray(name, v) |
| case int8: |
| return Int8Field(name, v) |
| case []int8: |
| return Int8Array(name, v) |
| case int16: |
| return Int16Field(name, v) |
| case []int16: |
| return Int16Array(name, v) |
| case int32: |
| return Int32Field(name, v) |
| case []int32: |
| return Int32Array(name, v) |
| case int64: |
| return Int64Field(name, v) |
| case []int64: |
| return Int64Array(name, v) |
| case uint: |
| return UintField(name, v) |
| case []uint: |
| return UintArray(name, v) |
| case uint8: |
| return Uint8Field(name, v) |
| case []uint8: |
| return Uint8Array(name, v) |
| case uint16: |
| return Uint16Field(name, v) |
| case []uint16: |
| return Uint16Array(name, v) |
| case uint32: |
| return Uint32Field(name, v) |
| case []uint32: |
| return Uint32Array(name, v) |
| case uint64: |
| return Uint64Field(name, v) |
| case []uint64: |
| return Uint64Array(name, v) |
| case uintptr: |
| return UintptrField(name, v) |
| case []uintptr: |
| return UintptrArray(name, v) |
| case float32: |
| return Float32Field(name, v) |
| case []float32: |
| return Float32Array(name, v) |
| case float64: |
| return Float64Field(name, v) |
| case []float64: |
| return Float64Array(name, v) |
| case error: |
| return StringField(name, v.Error()) |
| case time.Time: |
| return Time(name, v) |
| default: |
| switch rv := reflect.ValueOf(v); rv.Kind() { |
| case reflect.Bool: |
| return SmartField(name, rv.Bool()) |
| case reflect.Int: |
| return SmartField(name, int(rv.Int())) |
| case reflect.Int8: |
| return SmartField(name, int8(rv.Int())) |
| case reflect.Int16: |
| return SmartField(name, int16(rv.Int())) |
| case reflect.Int32: |
| return SmartField(name, int32(rv.Int())) |
| case reflect.Int64: |
| return SmartField(name, int64(rv.Int())) |
| case reflect.Uint: |
| return SmartField(name, uint(rv.Uint())) |
| case reflect.Uint8: |
| return SmartField(name, uint8(rv.Uint())) |
| case reflect.Uint16: |
| return SmartField(name, uint16(rv.Uint())) |
| case reflect.Uint32: |
| return SmartField(name, uint32(rv.Uint())) |
| case reflect.Uint64: |
| return SmartField(name, uint64(rv.Uint())) |
| case reflect.Uintptr: |
| return SmartField(name, uintptr(rv.Uint())) |
| case reflect.Float32: |
| return SmartField(name, float32(rv.Float())) |
| case reflect.Float64: |
| return SmartField(name, float64(rv.Float())) |
| case reflect.String: |
| return SmartField(name, rv.String()) |
| case reflect.Struct: |
| fields := make([]FieldOpt, 0, rv.NumField()) |
| for i := 0; i < rv.NumField(); i++ { |
| field := rv.Field(i) |
| if field.CanInterface() { |
| fields = append(fields, SmartField(name, field.Interface())) |
| } |
| } |
| return Struct(name, fields...) |
| } |
| } |
| |
| return StringField(name, fmt.Sprintf("(Unsupported: %T) %v", v, v)) |
| } |