| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // This file was auto-generated by the vanadium vdl tool. |
| // Package: vtrace |
| |
| package vtrace |
| |
| import ( |
| "fmt" |
| "time" |
| "v.io/v23/uniqueid" |
| "v.io/v23/vdl" |
| vdltime "v.io/v23/vdlroot/time" |
| ) |
| |
| var _ = __VDLInit() // Must be first; see __VDLInit comments for details. |
| |
| ////////////////////////////////////////////////// |
| // Type definitions |
| |
| // An Annotation represents data that is relevant at a specific moment. |
| // They can be attached to spans to add useful debugging information. |
| type Annotation struct { |
| // When the annotation was added. |
| When time.Time |
| // The annotation message. |
| // TODO(mattr): Allow richer annotations. |
| Message string |
| } |
| |
| func (Annotation) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vtrace.Annotation"` |
| }) { |
| } |
| |
| func (x Annotation) VDLIsZero() bool { |
| if !x.When.IsZero() { |
| return false |
| } |
| if x.Message != "" { |
| return false |
| } |
| return true |
| } |
| |
| func (x Annotation) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*Annotation)(nil)).Elem()); err != nil { |
| return err |
| } |
| if !x.When.IsZero() { |
| if err := enc.NextField("When"); err != nil { |
| return err |
| } |
| var wire vdltime.Time |
| if err := vdltime.TimeFromNative(&wire, x.When); err != nil { |
| return err |
| } |
| if err := wire.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.Message != "" { |
| if err := enc.NextField("Message"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.StringType); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(x.Message); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Annotation) VDLRead(dec vdl.Decoder) error { |
| *x = Annotation{} |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type()) |
| } |
| for { |
| f, err := dec.NextField() |
| if err != nil { |
| return err |
| } |
| switch f { |
| case "": |
| return dec.FinishValue() |
| case "When": |
| var wire vdltime.Time |
| if err := wire.VDLRead(dec); err != nil { |
| return err |
| } |
| if err := vdltime.TimeToNative(wire, &x.When); err != nil { |
| return err |
| } |
| case "Message": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if x.Message, err = dec.DecodeString(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| // A SpanRecord is the wire format for a Span. |
| type SpanRecord struct { |
| Id uniqueid.Id // The Id of the Span. |
| Parent uniqueid.Id // The Id of this Span's parent. |
| Name string // The Name of this span. |
| Start time.Time // The start time of this span. |
| End time.Time // The end time of this span. |
| // A series of annotations. |
| Annotations []Annotation |
| } |
| |
| func (SpanRecord) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vtrace.SpanRecord"` |
| }) { |
| } |
| |
| func (x SpanRecord) VDLIsZero() bool { |
| if x.Id != (uniqueid.Id{}) { |
| return false |
| } |
| if x.Parent != (uniqueid.Id{}) { |
| return false |
| } |
| if x.Name != "" { |
| return false |
| } |
| if !x.Start.IsZero() { |
| return false |
| } |
| if !x.End.IsZero() { |
| return false |
| } |
| if len(x.Annotations) != 0 { |
| return false |
| } |
| return true |
| } |
| |
| func (x SpanRecord) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*SpanRecord)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.Id != (uniqueid.Id{}) { |
| if err := enc.NextField("Id"); err != nil { |
| return err |
| } |
| if err := x.Id.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.Parent != (uniqueid.Id{}) { |
| if err := enc.NextField("Parent"); err != nil { |
| return err |
| } |
| if err := x.Parent.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.Name != "" { |
| if err := enc.NextField("Name"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.StringType); err != nil { |
| return err |
| } |
| if err := enc.EncodeString(x.Name); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if !x.Start.IsZero() { |
| if err := enc.NextField("Start"); err != nil { |
| return err |
| } |
| var wire vdltime.Time |
| if err := vdltime.TimeFromNative(&wire, x.Start); err != nil { |
| return err |
| } |
| if err := wire.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if !x.End.IsZero() { |
| if err := enc.NextField("End"); err != nil { |
| return err |
| } |
| var wire vdltime.Time |
| if err := vdltime.TimeFromNative(&wire, x.End); err != nil { |
| return err |
| } |
| if err := wire.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if len(x.Annotations) != 0 { |
| if err := enc.NextField("Annotations"); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_1(enc, x.Annotations); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_list_1(enc vdl.Encoder, x []Annotation) error { |
| if err := enc.StartValue(vdl.TypeOf((*[]Annotation)(nil))); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for i := 0; i < len(x); i++ { |
| if err := enc.NextEntry(false); err != nil { |
| return err |
| } |
| if err := x[i].VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *SpanRecord) VDLRead(dec vdl.Decoder) error { |
| *x = SpanRecord{} |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type()) |
| } |
| for { |
| f, err := dec.NextField() |
| if err != nil { |
| return err |
| } |
| switch f { |
| case "": |
| return dec.FinishValue() |
| case "Id": |
| if err := x.Id.VDLRead(dec); err != nil { |
| return err |
| } |
| case "Parent": |
| if err := x.Parent.VDLRead(dec); err != nil { |
| return err |
| } |
| case "Name": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| var err error |
| if x.Name, err = dec.DecodeString(); err != nil { |
| return err |
| } |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| case "Start": |
| var wire vdltime.Time |
| if err := wire.VDLRead(dec); err != nil { |
| return err |
| } |
| if err := vdltime.TimeToNative(wire, &x.Start); err != nil { |
| return err |
| } |
| case "End": |
| var wire vdltime.Time |
| if err := wire.VDLRead(dec); err != nil { |
| return err |
| } |
| if err := vdltime.TimeToNative(wire, &x.End); err != nil { |
| return err |
| } |
| case "Annotations": |
| if err := __VDLReadAnon_list_1(dec, &x.Annotations); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]Annotation) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type()) |
| } |
| switch len := dec.LenHint(); { |
| case len > 0: |
| *x = make([]Annotation, 0, len) |
| default: |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| } |
| var elem Annotation |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| |
| type TraceRecord struct { |
| Id uniqueid.Id |
| Spans []SpanRecord |
| } |
| |
| func (TraceRecord) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vtrace.TraceRecord"` |
| }) { |
| } |
| |
| func (x TraceRecord) VDLIsZero() bool { |
| if x.Id != (uniqueid.Id{}) { |
| return false |
| } |
| if len(x.Spans) != 0 { |
| return false |
| } |
| return true |
| } |
| |
| func (x TraceRecord) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*TraceRecord)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.Id != (uniqueid.Id{}) { |
| if err := enc.NextField("Id"); err != nil { |
| return err |
| } |
| if err := x.Id.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if len(x.Spans) != 0 { |
| if err := enc.NextField("Spans"); err != nil { |
| return err |
| } |
| if err := __VDLWriteAnon_list_2(enc, x.Spans); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func __VDLWriteAnon_list_2(enc vdl.Encoder, x []SpanRecord) error { |
| if err := enc.StartValue(vdl.TypeOf((*[]SpanRecord)(nil))); err != nil { |
| return err |
| } |
| if err := enc.SetLenHint(len(x)); err != nil { |
| return err |
| } |
| for i := 0; i < len(x); i++ { |
| if err := enc.NextEntry(false); err != nil { |
| return err |
| } |
| if err := x[i].VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextEntry(true); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *TraceRecord) VDLRead(dec vdl.Decoder) error { |
| *x = TraceRecord{} |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type()) |
| } |
| for { |
| f, err := dec.NextField() |
| if err != nil { |
| return err |
| } |
| switch f { |
| case "": |
| return dec.FinishValue() |
| case "Id": |
| if err := x.Id.VDLRead(dec); err != nil { |
| return err |
| } |
| case "Spans": |
| if err := __VDLReadAnon_list_2(dec, &x.Spans); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| func __VDLReadAnon_list_2(dec vdl.Decoder, x *[]SpanRecord) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type()) |
| } |
| switch len := dec.LenHint(); { |
| case len > 0: |
| *x = make([]SpanRecord, 0, len) |
| default: |
| *x = nil |
| } |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return dec.FinishValue() |
| } |
| var elem SpanRecord |
| if err := elem.VDLRead(dec); err != nil { |
| return err |
| } |
| *x = append(*x, elem) |
| } |
| } |
| |
| type TraceFlags int32 |
| |
| func (TraceFlags) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vtrace.TraceFlags"` |
| }) { |
| } |
| |
| func (x TraceFlags) VDLIsZero() bool { |
| return x == 0 |
| } |
| |
| func (x TraceFlags) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*TraceFlags)(nil))); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x)); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *TraceFlags) VDLRead(dec vdl.Decoder) error { |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| *x = TraceFlags(tmp) |
| return dec.FinishValue() |
| } |
| |
| // Request is the object that carries trace informtion between processes. |
| type Request struct { |
| SpanId uniqueid.Id // The Id of the span that originated the RPC call. |
| TraceId uniqueid.Id // The Id of the trace this call is a part of. |
| Flags TraceFlags |
| LogLevel int32 |
| } |
| |
| func (Request) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vtrace.Request"` |
| }) { |
| } |
| |
| func (x Request) VDLIsZero() bool { |
| return x == Request{} |
| } |
| |
| func (x Request) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*Request)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.SpanId != (uniqueid.Id{}) { |
| if err := enc.NextField("SpanId"); err != nil { |
| return err |
| } |
| if err := x.SpanId.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.TraceId != (uniqueid.Id{}) { |
| if err := enc.NextField("TraceId"); err != nil { |
| return err |
| } |
| if err := x.TraceId.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.Flags != 0 { |
| if err := enc.NextField("Flags"); err != nil { |
| return err |
| } |
| if err := x.Flags.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if x.LogLevel != 0 { |
| if err := enc.NextField("LogLevel"); err != nil { |
| return err |
| } |
| if err := enc.StartValue(vdl.Int32Type); err != nil { |
| return err |
| } |
| if err := enc.EncodeInt(int64(x.LogLevel)); err != nil { |
| return err |
| } |
| if err := enc.FinishValue(); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Request) VDLRead(dec vdl.Decoder) error { |
| *x = Request{} |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type()) |
| } |
| for { |
| f, err := dec.NextField() |
| if err != nil { |
| return err |
| } |
| switch f { |
| case "": |
| return dec.FinishValue() |
| case "SpanId": |
| if err := x.SpanId.VDLRead(dec); err != nil { |
| return err |
| } |
| case "TraceId": |
| if err := x.TraceId.VDLRead(dec); err != nil { |
| return err |
| } |
| case "Flags": |
| if err := x.Flags.VDLRead(dec); err != nil { |
| return err |
| } |
| case "LogLevel": |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| tmp, err := dec.DecodeInt(32) |
| if err != nil { |
| return err |
| } |
| x.LogLevel = int32(tmp) |
| if err := dec.FinishValue(); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| type Response struct { |
| // Flags give options for trace collection, the client should alter its |
| // collection for this trace according to the flags sent back from the |
| // server. |
| Flags TraceFlags |
| // Trace is collected trace data. This may be empty. |
| Trace TraceRecord |
| } |
| |
| func (Response) __VDLReflect(struct { |
| Name string `vdl:"v.io/v23/vtrace.Response"` |
| }) { |
| } |
| |
| func (x Response) VDLIsZero() bool { |
| if x.Flags != 0 { |
| return false |
| } |
| if !x.Trace.VDLIsZero() { |
| return false |
| } |
| return true |
| } |
| |
| func (x Response) VDLWrite(enc vdl.Encoder) error { |
| if err := enc.StartValue(vdl.TypeOf((*Response)(nil)).Elem()); err != nil { |
| return err |
| } |
| if x.Flags != 0 { |
| if err := enc.NextField("Flags"); err != nil { |
| return err |
| } |
| if err := x.Flags.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if !x.Trace.VDLIsZero() { |
| if err := enc.NextField("Trace"); err != nil { |
| return err |
| } |
| if err := x.Trace.VDLWrite(enc); err != nil { |
| return err |
| } |
| } |
| if err := enc.NextField(""); err != nil { |
| return err |
| } |
| return enc.FinishValue() |
| } |
| |
| func (x *Response) VDLRead(dec vdl.Decoder) error { |
| *x = Response{} |
| if err := dec.StartValue(); err != nil { |
| return err |
| } |
| if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) { |
| return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type()) |
| } |
| for { |
| f, err := dec.NextField() |
| if err != nil { |
| return err |
| } |
| switch f { |
| case "": |
| return dec.FinishValue() |
| case "Flags": |
| if err := x.Flags.VDLRead(dec); err != nil { |
| return err |
| } |
| case "Trace": |
| if err := x.Trace.VDLRead(dec); err != nil { |
| return err |
| } |
| default: |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| } |
| } |
| } |
| |
| ////////////////////////////////////////////////// |
| // Const definitions |
| |
| const Empty = TraceFlags(0) |
| const CollectInMemory = TraceFlags(1) |
| |
| var __VDLInitCalled bool |
| |
| // __VDLInit performs vdl initialization. It is safe to call multiple times. |
| // If you have an init ordering issue, just insert the following line verbatim |
| // into your source files in this package, right after the "package foo" clause: |
| // |
| // var _ = __VDLInit() |
| // |
| // The purpose of this function is to ensure that vdl initialization occurs in |
| // the right order, and very early in the init sequence. In particular, vdl |
| // registration and package variable initialization needs to occur before |
| // functions like vdl.TypeOf will work properly. |
| // |
| // This function returns a dummy value, so that it can be used to initialize the |
| // first var in the file, to take advantage of Go's defined init order. |
| func __VDLInit() struct{} { |
| if __VDLInitCalled { |
| return struct{}{} |
| } |
| __VDLInitCalled = true |
| |
| // Register types. |
| vdl.Register((*Annotation)(nil)) |
| vdl.Register((*SpanRecord)(nil)) |
| vdl.Register((*TraceRecord)(nil)) |
| vdl.Register((*TraceFlags)(nil)) |
| vdl.Register((*Request)(nil)) |
| vdl.Register((*Response)(nil)) |
| |
| return struct{}{} |
| } |