metric.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: util/metric/metric.proto

package metric

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
	proto "github.com/gogo/protobuf/proto"
	_go "github.com/prometheus/client_model/go"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// DisplayUnit describes how the metric's units should be displayed in charts.
type Unit int32

const (
	// UNSET expresses that the metric's DisplayUnit wasn't explicitly set.
	Unit_UNSET Unit = 0
	// BYTES expresses that the metric's measurement is in bytes.
	Unit_BYTES Unit = 1
	// CONST expresses that the metric's measurement is a constant value.
	Unit_CONST Unit = 2
	// COUNT expresses that the metric's measurement is a count.
	Unit_COUNT Unit = 3
	// NANOSECONDS expresses that the metric's measurement is in nanoseconds.
	Unit_NANOSECONDS Unit = 4
	// PERCENT expresses that the metric's measurement is a percentage value.
	Unit_PERCENT Unit = 5
	// SECONDS expresses that the metric's measurement is in seconds.
	Unit_SECONDS Unit = 6
	// TIMESTAMP_NS expresses that the metric's measurement is a time since the
	// Unix epoch in nanoseconds.
	Unit_TIMESTAMP_NS Unit = 7
	// TIMESTAMP_SEC expresses that the metric's measurement is a time since the
	// Unix epoch in seconds.
	Unit_TIMESTAMP_SEC Unit = 8
)

var Unit_name = map[int32]string{
	0: "UNSET",
	1: "BYTES",
	2: "CONST",
	3: "COUNT",
	4: "NANOSECONDS",
	5: "PERCENT",
	6: "SECONDS",
	7: "TIMESTAMP_NS",
	8: "TIMESTAMP_SEC",
}

var Unit_value = map[string]int32{
	"UNSET":         0,
	"BYTES":         1,
	"CONST":         2,
	"COUNT":         3,
	"NANOSECONDS":   4,
	"PERCENT":       5,
	"SECONDS":       6,
	"TIMESTAMP_NS":  7,
	"TIMESTAMP_SEC": 8,
}

func (x Unit) Enum() *Unit {
	p := new(Unit)
	*p = x
	return p
}

func (x Unit) String() string {
	return proto.EnumName(Unit_name, int32(x))
}

func (x *Unit) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Unit_value, data, "Unit")
	if err != nil {
		return err
	}
	*x = Unit(value)
	return nil
}

func (Unit) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8d59dd1524693214, []int{0}
}

// metric.LabelPair is a proxy for io.prometheus.client.LabelPair.
// io.prometheus.client.LabelPair doesn't support gogoproto.marshaler
// and gogoproto.unmarshaler which are required by gRPC. metric.LabelPair
// stores information that is similarly structured, supports the requisite
// gogoproto options, and is convertible to io.prometheus.client.LabelPair
// to satisfy PrometheusExportable's GetLabels method.
type LabelPair struct {
	Name  *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
}

func (m *LabelPair) Reset()         { *m = LabelPair{} }
func (m *LabelPair) String() string { return proto.CompactTextString(m) }
func (*LabelPair) ProtoMessage()    {}
func (*LabelPair) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d59dd1524693214, []int{0}
}
func (m *LabelPair) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LabelPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *LabelPair) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LabelPair.Merge(m, src)
}
func (m *LabelPair) XXX_Size() int {
	return m.Size()
}
func (m *LabelPair) XXX_DiscardUnknown() {
	xxx_messageInfo_LabelPair.DiscardUnknown(m)
}

var xxx_messageInfo_LabelPair proto.InternalMessageInfo

// Metadata holds metadata about a metric. It must be embedded in
// each metric object. It's used to export information about the
// metric to Prometheus and for Admin UI charts.
type Metadata struct {
	Name        string         `protobuf:"bytes,1,req,name=name" json:"name"`
	Help        string         `protobuf:"bytes,2,req,name=help" json:"help"`
	Measurement string         `protobuf:"bytes,3,req,name=measurement" json:"measurement"`
	Unit        Unit           `protobuf:"varint,4,req,name=unit,enum=cockroach.util.metric.Unit" json:"unit"`
	MetricType  _go.MetricType `protobuf:"varint,5,opt,name=metricType,enum=io.prometheus.client.MetricType" json:"metricType"`
	Labels      []*LabelPair   `protobuf:"bytes,6,rep,name=labels" json:"labels,omitempty"`
}

func (m *Metadata) Reset()         { *m = Metadata{} }
func (m *Metadata) String() string { return proto.CompactTextString(m) }
func (*Metadata) ProtoMessage()    {}
func (*Metadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d59dd1524693214, []int{1}
}
func (m *Metadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Metadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Metadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Metadata.Merge(m, src)
}
func (m *Metadata) XXX_Size() int {
	return m.Size()
}
func (m *Metadata) XXX_DiscardUnknown() {
	xxx_messageInfo_Metadata.DiscardUnknown(m)
}

var xxx_messageInfo_Metadata proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("cockroach.util.metric.Unit", Unit_name, Unit_value)
	proto.RegisterType((*LabelPair)(nil), "cockroach.util.metric.LabelPair")
	proto.RegisterType((*Metadata)(nil), "cockroach.util.metric.Metadata")
}

func init() { proto.RegisterFile("util/metric/metric.proto", fileDescriptor_8d59dd1524693214) }

var fileDescriptor_8d59dd1524693214 = []byte{
	// 429 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0x41, 0x8b, 0xd3, 0x40,
	0x14, 0xc7, 0x33, 0x69, 0xda, 0xdd, 0xbe, 0xea, 0x3a, 0x0e, 0x2b, 0x0c, 0x2b, 0xc4, 0xb0, 0xa0,
	0x04, 0x0f, 0x29, 0x14, 0x16, 0xbc, 0x6e, 0x6b, 0x04, 0xc1, 0xa6, 0xa5, 0x99, 0x1e, 0xf4, 0xb2,
	0x8c, 0xd9, 0x61, 0x1b, 0x4c, 0x32, 0x25, 0x9d, 0x08, 0x5e, 0xfd, 0x04, 0x7e, 0x03, 0xbf, 0x4e,
	0x8f, 0x7b, 0xec, 0x49, 0xb4, 0xfd, 0x22, 0x32, 0x9d, 0xb4, 0xe6, 0xe0, 0x9e, 0xe6, 0xff, 0xde,
	0xff, 0xf7, 0x1e, 0x6f, 0xfe, 0x40, 0x2b, 0x95, 0x66, 0xfd, 0x5c, 0xa8, 0x32, 0x4d, 0xea, 0x27,
	0x58, 0x96, 0x52, 0x49, 0xf2, 0x2c, 0x91, 0xc9, 0x97, 0x52, 0xf2, 0x64, 0x11, 0x68, 0x26, 0x30,
	0xe6, 0xc5, 0xf9, 0x9d, 0xbc, 0x93, 0x7b, 0xa2, 0xaf, 0x95, 0x81, 0x2f, 0x5e, 0x2e, 0x4b, 0x99,
	0x0b, 0xb5, 0x10, 0xd5, 0xaa, 0x9f, 0x64, 0xa9, 0x28, 0xd4, 0x4d, 0x2e, 0x6f, 0xc5, 0x61, 0xf3,
	0xca, 0x60, 0x97, 0x57, 0xd0, 0xfd, 0xc0, 0x3f, 0x8b, 0x6c, 0xca, 0xd3, 0x92, 0x10, 0x70, 0x0a,
	0x9e, 0x0b, 0x8a, 0x3c, 0xe4, 0x77, 0x67, 0x7b, 0x4d, 0xce, 0xa1, 0xfd, 0x95, 0x67, 0x95, 0xa0,
	0xf6, 0xbe, 0x69, 0x8a, 0xcb, 0x9f, 0x36, 0x9c, 0x8e, 0x85, 0xe2, 0xb7, 0x5c, 0x71, 0x42, 0x8f,
	0x63, 0xb6, 0xdf, 0x1d, 0x3a, 0xeb, 0x5f, 0x2f, 0xac, 0x7a, 0x98, 0x82, 0xb3, 0x10, 0xd9, 0x92,
	0xda, 0x4d, 0x47, 0x77, 0xc8, 0x2b, 0xe8, 0xe5, 0x82, 0xaf, 0xaa, 0x52, 0xe4, 0xa2, 0x50, 0xb4,
	0xd5, 0x00, 0x9a, 0x06, 0xb9, 0x02, 0xa7, 0x2a, 0x52, 0x45, 0x1d, 0xcf, 0xf6, 0xcf, 0x06, 0xcf,
	0x83, 0xff, 0x46, 0x10, 0xcc, 0x8b, 0x54, 0x1d, 0xd6, 0x6b, 0x9c, 0xbc, 0x03, 0x30, 0x16, 0xfb,
	0xb6, 0x14, 0xb4, 0xed, 0x21, 0xff, 0x6c, 0xe0, 0x05, 0xe9, 0x3e, 0x9c, 0x3a, 0x95, 0xc0, 0xa4,
	0x12, 0x8c, 0x8f, 0x5c, 0xbd, 0xa1, 0x31, 0x49, 0xde, 0x40, 0x27, 0xd3, 0xf1, 0xac, 0x68, 0xc7,
	0x6b, 0xf9, 0xbd, 0x81, 0xf7, 0xc0, 0x01, 0xc7, 0x0c, 0x67, 0x35, 0xff, 0xfa, 0x3b, 0x02, 0x47,
	0x9f, 0x45, 0xba, 0xd0, 0x9e, 0x47, 0x71, 0xc8, 0xb0, 0xa5, 0xe5, 0xf0, 0x23, 0x0b, 0x63, 0x8c,
	0xb4, 0x1c, 0x4d, 0xa2, 0x98, 0x61, 0xdb, 0xc8, 0x79, 0xc4, 0x70, 0x8b, 0x3c, 0x81, 0x5e, 0x74,
	0x1d, 0x4d, 0xe2, 0x70, 0x34, 0x89, 0xde, 0xc6, 0xd8, 0x21, 0x3d, 0x38, 0x99, 0x86, 0xb3, 0x51,
	0x18, 0x31, 0xdc, 0xd6, 0xc5, 0xc1, 0xe9, 0x10, 0x0c, 0x8f, 0xd8, 0xfb, 0x71, 0x18, 0xb3, 0xeb,
	0xf1, 0xf4, 0x26, 0x8a, 0xf1, 0x09, 0x79, 0x0a, 0x8f, 0xff, 0x75, 0xe2, 0x70, 0x84, 0x4f, 0x87,
	0xfe, 0xfa, 0x8f, 0x6b, 0xad, 0xb7, 0x2e, 0xba, 0xdf, 0xba, 0x68, 0xb3, 0x75, 0xd1, 0xef, 0xad,
	0x8b, 0x7e, 0xec, 0x5c, 0xeb, 0x7e, 0xe7, 0x5a, 0x9b, 0x9d, 0x6b, 0x7d, 0xea, 0x98, 0x0f, 0xfc,
	0x0d, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x8f, 0x03, 0x28, 0x76, 0x02, 0x00, 0x00,
}

func (m *LabelPair) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LabelPair) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Name != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintMetric(dAtA, i, uint64(len(*m.Name)))
		i += copy(dAtA[i:], *m.Name)
	}
	if m.Value != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintMetric(dAtA, i, uint64(len(*m.Value)))
		i += copy(dAtA[i:], *m.Value)
	}
	return i, nil
}

func (m *Metadata) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Metadata) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetric(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetric(dAtA, i, uint64(len(m.Help)))
	i += copy(dAtA[i:], m.Help)
	dAtA[i] = 0x1a
	i++
	i = encodeVarintMetric(dAtA, i, uint64(len(m.Measurement)))
	i += copy(dAtA[i:], m.Measurement)
	dAtA[i] = 0x20
	i++
	i = encodeVarintMetric(dAtA, i, uint64(m.Unit))
	dAtA[i] = 0x28
	i++
	i = encodeVarintMetric(dAtA, i, uint64(m.MetricType))
	if len(m.Labels) > 0 {
		for _, msg := range m.Labels {
			dAtA[i] = 0x32
			i++
			i = encodeVarintMetric(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func encodeVarintMetric(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *LabelPair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Name != nil {
		l = len(*m.Name)
		n += 1 + l + sovMetric(uint64(l))
	}
	if m.Value != nil {
		l = len(*m.Value)
		n += 1 + l + sovMetric(uint64(l))
	}
	return n
}

func (m *Metadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovMetric(uint64(l))
	l = len(m.Help)
	n += 1 + l + sovMetric(uint64(l))
	l = len(m.Measurement)
	n += 1 + l + sovMetric(uint64(l))
	n += 1 + sovMetric(uint64(m.Unit))
	n += 1 + sovMetric(uint64(m.MetricType))
	if len(m.Labels) > 0 {
		for _, e := range m.Labels {
			l = e.Size()
			n += 1 + l + sovMetric(uint64(l))
		}
	}
	return n
}

func sovMetric(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMetric(x uint64) (n int) {
	return sovMetric(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *LabelPair) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetric
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LabelPair: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LabelPair: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetric
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetric
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetric
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Name = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetric
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetric
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetric
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Value = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetric(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetric
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMetric
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Metadata) Unmarshal(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetric
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Metadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Metadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetric
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetric
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetric
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Help", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetric
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetric
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetric
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Help = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000002)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Measurement", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetric
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetric
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetric
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Measurement = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000004)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
			}
			m.Unit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetric
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Unit |= Unit(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			hasFields[0] |= uint64(0x00000008)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricType", wireType)
			}
			m.MetricType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetric
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MetricType |= _go.MetricType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetric
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetric
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetric
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = append(m.Labels, &LabelPair{})
			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetric(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetric
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMetric
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("name")
	}
	if hasFields[0]&uint64(0x00000002) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("help")
	}
	if hasFields[0]&uint64(0x00000004) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("measurement")
	}
	if hasFields[0]&uint64(0x00000008) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("unit")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMetric(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowMetric
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMetric
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMetric
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthMetric
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthMetric
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowMetric
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipMetric(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthMetric
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthMetric = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMetric   = fmt.Errorf("proto: integer overflow")
)