data_receiver

package

Go to main page

Versions in this module

v1

v1.5.1

May 10, 2024

Changes in this version

+ const DataReceiverService_PutEvent_FullMethodName

+ const DataReceiverService_PutEvents_FullMethodName

+ const DataReceiverService_PutMetric_FullMethodName

+ const DataReceiverService_PutMetrics_FullMethodName

+ const DataReceiverService_PutModels_FullMethodName

type MockDataReceiverServiceClient_PutEvent_Call

+ func (_c *MockDataReceiverServiceClient_PutEvent_Call) RunAndReturn(...) *MockDataReceiverServiceClient_PutEvent_Call

type MockDataReceiverServiceClient_PutEvents_Call

+ func (_c *MockDataReceiverServiceClient_PutEvents_Call) RunAndReturn(...) *MockDataReceiverServiceClient_PutEvents_Call

type MockDataReceiverServiceClient_PutMetric_Call

+ func (_c *MockDataReceiverServiceClient_PutMetric_Call) RunAndReturn(...) *MockDataReceiverServiceClient_PutMetric_Call

type MockDataReceiverServiceClient_PutMetrics_Call

+ func (_c *MockDataReceiverServiceClient_PutMetrics_Call) RunAndReturn(run func(context.Context, *Metrics, ...grpc.CallOption) (*StatusResult, error)) *MockDataReceiverServiceClient_PutMetrics_Call

type MockDataReceiverServiceClient_PutModels_Call

+ func (_c *MockDataReceiverServiceClient_PutModels_Call) RunAndReturn(...) *MockDataReceiverServiceClient_PutModels_Call

type MockDataReceiverServiceServer_PutEvent_Call

+ func (_c *MockDataReceiverServiceServer_PutEvent_Call) RunAndReturn(run func(DataReceiverService_PutEventServer) error) *MockDataReceiverServiceServer_PutEvent_Call

type MockDataReceiverServiceServer_PutEvents_Call

+ func (_c *MockDataReceiverServiceServer_PutEvents_Call) RunAndReturn(run func(context.Context, *Events) (*EventStatusResult, error)) *MockDataReceiverServiceServer_PutEvents_Call

type MockDataReceiverServiceServer_PutMetric_Call

+ func (_c *MockDataReceiverServiceServer_PutMetric_Call) RunAndReturn(run func(DataReceiverService_PutMetricServer) error) *MockDataReceiverServiceServer_PutMetric_Call

type MockDataReceiverServiceServer_PutMetrics_Call

+ func (_c *MockDataReceiverServiceServer_PutMetrics_Call) RunAndReturn(run func(context.Context, *Metrics) (*StatusResult, error)) *MockDataReceiverServiceServer_PutMetrics_Call

type MockDataReceiverServiceServer_PutModels_Call

+ func (_c *MockDataReceiverServiceServer_PutModels_Call) RunAndReturn(run func(context.Context, *Models) (*ModelStatusResult, error)) *MockDataReceiverServiceServer_PutModels_Call

type MockDataReceiverServiceServer_mustEmbedUnimplementedDataReceiverServiceServer_Call

+ func (_c *MockDataReceiverServiceServer_mustEmbedUnimplementedDataReceiverServiceServer_Call) RunAndReturn(run func()) ...

type MockDataReceiverService_PutEventClient_CloseAndRecv_Call

+ func (_c *MockDataReceiverService_PutEventClient_CloseAndRecv_Call) RunAndReturn(run func() (*Void, error)) *MockDataReceiverService_PutEventClient_CloseAndRecv_Call

type MockDataReceiverService_PutEventClient_CloseSend_Call

+ func (_c *MockDataReceiverService_PutEventClient_CloseSend_Call) RunAndReturn(run func() error) *MockDataReceiverService_PutEventClient_CloseSend_Call

type MockDataReceiverService_PutEventClient_Context_Call

+ func (_c *MockDataReceiverService_PutEventClient_Context_Call) RunAndReturn(run func() context.Context) *MockDataReceiverService_PutEventClient_Context_Call

type MockDataReceiverService_PutEventClient_Header_Call

+ func (_c *MockDataReceiverService_PutEventClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *MockDataReceiverService_PutEventClient_Header_Call

type MockDataReceiverService_PutEventClient_RecvMsg_Call

+ func (_c *MockDataReceiverService_PutEventClient_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockDataReceiverService_PutEventClient_RecvMsg_Call

type MockDataReceiverService_PutEventClient_SendMsg_Call

+ func (_c *MockDataReceiverService_PutEventClient_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockDataReceiverService_PutEventClient_SendMsg_Call

type MockDataReceiverService_PutEventClient_Send_Call

+ func (_c *MockDataReceiverService_PutEventClient_Send_Call) RunAndReturn(run func(*EventWrapper) error) *MockDataReceiverService_PutEventClient_Send_Call

type MockDataReceiverService_PutEventClient_Trailer_Call

+ func (_c *MockDataReceiverService_PutEventClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *MockDataReceiverService_PutEventClient_Trailer_Call

type MockDataReceiverService_PutEventServer_Context_Call

+ func (_c *MockDataReceiverService_PutEventServer_Context_Call) RunAndReturn(run func() context.Context) *MockDataReceiverService_PutEventServer_Context_Call

type MockDataReceiverService_PutEventServer_RecvMsg_Call

+ func (_c *MockDataReceiverService_PutEventServer_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockDataReceiverService_PutEventServer_RecvMsg_Call

type MockDataReceiverService_PutEventServer_Recv_Call

+ func (_c *MockDataReceiverService_PutEventServer_Recv_Call) RunAndReturn(run func() (*EventWrapper, error)) *MockDataReceiverService_PutEventServer_Recv_Call

type MockDataReceiverService_PutEventServer_SendAndClose_Call

+ func (_c *MockDataReceiverService_PutEventServer_SendAndClose_Call) RunAndReturn(run func(*Void) error) *MockDataReceiverService_PutEventServer_SendAndClose_Call

type MockDataReceiverService_PutEventServer_SendHeader_Call

+ func (_c *MockDataReceiverService_PutEventServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockDataReceiverService_PutEventServer_SendHeader_Call

type MockDataReceiverService_PutEventServer_SendMsg_Call

+ func (_c *MockDataReceiverService_PutEventServer_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockDataReceiverService_PutEventServer_SendMsg_Call

type MockDataReceiverService_PutEventServer_SetHeader_Call

+ func (_c *MockDataReceiverService_PutEventServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockDataReceiverService_PutEventServer_SetHeader_Call

type MockDataReceiverService_PutEventServer_SetTrailer_Call

+ func (_c *MockDataReceiverService_PutEventServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *MockDataReceiverService_PutEventServer_SetTrailer_Call

type MockDataReceiverService_PutMetricClient_CloseAndRecv_Call

+ func (_c *MockDataReceiverService_PutMetricClient_CloseAndRecv_Call) RunAndReturn(run func() (*Void, error)) *MockDataReceiverService_PutMetricClient_CloseAndRecv_Call

type MockDataReceiverService_PutMetricClient_CloseSend_Call

+ func (_c *MockDataReceiverService_PutMetricClient_CloseSend_Call) RunAndReturn(run func() error) *MockDataReceiverService_PutMetricClient_CloseSend_Call

type MockDataReceiverService_PutMetricClient_Context_Call

+ func (_c *MockDataReceiverService_PutMetricClient_Context_Call) RunAndReturn(run func() context.Context) *MockDataReceiverService_PutMetricClient_Context_Call

type MockDataReceiverService_PutMetricClient_Header_Call

+ func (_c *MockDataReceiverService_PutMetricClient_Header_Call) RunAndReturn(run func() (metadata.MD, error)) *MockDataReceiverService_PutMetricClient_Header_Call

type MockDataReceiverService_PutMetricClient_RecvMsg_Call

+ func (_c *MockDataReceiverService_PutMetricClient_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockDataReceiverService_PutMetricClient_RecvMsg_Call

type MockDataReceiverService_PutMetricClient_SendMsg_Call

+ func (_c *MockDataReceiverService_PutMetricClient_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockDataReceiverService_PutMetricClient_SendMsg_Call

type MockDataReceiverService_PutMetricClient_Send_Call

+ func (_c *MockDataReceiverService_PutMetricClient_Send_Call) RunAndReturn(run func(*MetricWrapper) error) *MockDataReceiverService_PutMetricClient_Send_Call

type MockDataReceiverService_PutMetricClient_Trailer_Call

+ func (_c *MockDataReceiverService_PutMetricClient_Trailer_Call) RunAndReturn(run func() metadata.MD) *MockDataReceiverService_PutMetricClient_Trailer_Call

type MockDataReceiverService_PutMetricServer_Context_Call

+ func (_c *MockDataReceiverService_PutMetricServer_Context_Call) RunAndReturn(run func() context.Context) *MockDataReceiverService_PutMetricServer_Context_Call

type MockDataReceiverService_PutMetricServer_RecvMsg_Call

+ func (_c *MockDataReceiverService_PutMetricServer_RecvMsg_Call) RunAndReturn(run func(interface{}) error) *MockDataReceiverService_PutMetricServer_RecvMsg_Call

type MockDataReceiverService_PutMetricServer_Recv_Call

+ func (_c *MockDataReceiverService_PutMetricServer_Recv_Call) RunAndReturn(run func() (*MetricWrapper, error)) *MockDataReceiverService_PutMetricServer_Recv_Call

type MockDataReceiverService_PutMetricServer_SendAndClose_Call

+ func (_c *MockDataReceiverService_PutMetricServer_SendAndClose_Call) RunAndReturn(run func(*Void) error) *MockDataReceiverService_PutMetricServer_SendAndClose_Call

type MockDataReceiverService_PutMetricServer_SendHeader_Call

+ func (_c *MockDataReceiverService_PutMetricServer_SendHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockDataReceiverService_PutMetricServer_SendHeader_Call

type MockDataReceiverService_PutMetricServer_SendMsg_Call

+ func (_c *MockDataReceiverService_PutMetricServer_SendMsg_Call) RunAndReturn(run func(interface{}) error) *MockDataReceiverService_PutMetricServer_SendMsg_Call

type MockDataReceiverService_PutMetricServer_SetHeader_Call

+ func (_c *MockDataReceiverService_PutMetricServer_SetHeader_Call) RunAndReturn(run func(metadata.MD) error) *MockDataReceiverService_PutMetricServer_SetHeader_Call

type MockDataReceiverService_PutMetricServer_SetTrailer_Call

+ func (_c *MockDataReceiverService_PutMetricServer_SetTrailer_Call) RunAndReturn(run func(metadata.MD)) *MockDataReceiverService_PutMetricServer_SetTrailer_Call

type MockUnsafeDataReceiverServiceServer_mustEmbedUnimplementedDataReceiverServiceServer_Call

+ func (_c *MockUnsafeDataReceiverServiceServer_mustEmbedUnimplementedDataReceiverServiceServer_Call) RunAndReturn(run func()) ...

v1.5.0

Dec 19, 2022

Changes in this version

+ var DataReceiverService_ServiceDesc = grpc.ServiceDesc

+ type MockDataReceiverServiceServer_mustEmbedUnimplementedDataReceiverServiceServer_Call struct

+ func (_c *MockDataReceiverServiceServer_mustEmbedUnimplementedDataReceiverServiceServer_Call) Return() ...

+ func (_c *MockDataReceiverServiceServer_mustEmbedUnimplementedDataReceiverServiceServer_Call) Run(run func()) ...

+ type MockUnsafeDataReceiverServiceServer struct

+ func NewMockUnsafeDataReceiverServiceServer(t mockConstructorTestingTNewMockUnsafeDataReceiverServiceServer) *MockUnsafeDataReceiverServiceServer

+ func (_m *MockUnsafeDataReceiverServiceServer) EXPECT() *MockUnsafeDataReceiverServiceServer_Expecter

+ type MockUnsafeDataReceiverServiceServer_Expecter struct

+ type MockUnsafeDataReceiverServiceServer_mustEmbedUnimplementedDataReceiverServiceServer_Call struct

+ func (_c *MockUnsafeDataReceiverServiceServer_mustEmbedUnimplementedDataReceiverServiceServer_Call) Return() ...

+ func (_c *MockUnsafeDataReceiverServiceServer_mustEmbedUnimplementedDataReceiverServiceServer_Call) Run(run func()) ...

+ type UnsafeDataReceiverServiceServer interface

v1.4.1

Oct 21, 2022

v1.4.0

Jun 20, 2022

Changes in this version

+ var File_zenoss_cloud_data_receiver_proto protoreflect.FileDescriptor

+ func RegisterDataReceiverServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server DataReceiverServiceServer) error

type CompactMetric

+ func (x *CompactMetric) ProtoReflect() protoreflect.Message

type CompactMetricError

+ func (x *CompactMetricError) ProtoReflect() protoreflect.Message

type Event

+ func (x *Event) ProtoReflect() protoreflect.Message

type EventError

+ func (x *EventError) ProtoReflect() protoreflect.Message

type EventStatusResult

+ func (x *EventStatusResult) ProtoReflect() protoreflect.Message

type EventWrapper

+ func (x *EventWrapper) ProtoReflect() protoreflect.Message

type Events

+ func (x *Events) ProtoReflect() protoreflect.Message

type Metric

+ func (x *Metric) ProtoReflect() protoreflect.Message

type MetricBatch

+ func (x *MetricBatch) ProtoReflect() protoreflect.Message

type MetricError

+ func (x *MetricError) ProtoReflect() protoreflect.Message

type MetricWrapper

+ func (x *MetricWrapper) ProtoReflect() protoreflect.Message

type Metrics

+ func (x *Metrics) ProtoReflect() protoreflect.Message

type MockDataReceiverServiceClient

+ func NewMockDataReceiverServiceClient(t testing.TB) *MockDataReceiverServiceClient

+ func (_m *MockDataReceiverServiceClient) EXPECT() *MockDataReceiverServiceClient_Expecter

+ type MockDataReceiverServiceClient_Expecter struct

+ func (_e *MockDataReceiverServiceClient_Expecter) PutEvent(ctx interface{}, opts ...interface{}) *MockDataReceiverServiceClient_PutEvent_Call

+ func (_e *MockDataReceiverServiceClient_Expecter) PutEvents(ctx interface{}, in interface{}, opts ...interface{}) *MockDataReceiverServiceClient_PutEvents_Call

+ func (_e *MockDataReceiverServiceClient_Expecter) PutMetric(ctx interface{}, opts ...interface{}) *MockDataReceiverServiceClient_PutMetric_Call

+ func (_e *MockDataReceiverServiceClient_Expecter) PutMetrics(ctx interface{}, in interface{}, opts ...interface{}) *MockDataReceiverServiceClient_PutMetrics_Call

+ func (_e *MockDataReceiverServiceClient_Expecter) PutModels(ctx interface{}, in interface{}, opts ...interface{}) *MockDataReceiverServiceClient_PutModels_Call

+ type MockDataReceiverServiceClient_PutEvent_Call struct

+ func (_c *MockDataReceiverServiceClient_PutEvent_Call) Return(_a0 DataReceiverService_PutEventClient, _a1 error) *MockDataReceiverServiceClient_PutEvent_Call

+ func (_c *MockDataReceiverServiceClient_PutEvent_Call) Run(run func(ctx context.Context, opts ...grpc.CallOption)) *MockDataReceiverServiceClient_PutEvent_Call

+ type MockDataReceiverServiceClient_PutEvents_Call struct

+ func (_c *MockDataReceiverServiceClient_PutEvents_Call) Return(_a0 *EventStatusResult, _a1 error) *MockDataReceiverServiceClient_PutEvents_Call

+ func (_c *MockDataReceiverServiceClient_PutEvents_Call) Run(run func(ctx context.Context, in *Events, opts ...grpc.CallOption)) *MockDataReceiverServiceClient_PutEvents_Call

+ type MockDataReceiverServiceClient_PutMetric_Call struct

+ func (_c *MockDataReceiverServiceClient_PutMetric_Call) Return(_a0 DataReceiverService_PutMetricClient, _a1 error) *MockDataReceiverServiceClient_PutMetric_Call

+ func (_c *MockDataReceiverServiceClient_PutMetric_Call) Run(run func(ctx context.Context, opts ...grpc.CallOption)) *MockDataReceiverServiceClient_PutMetric_Call

+ type MockDataReceiverServiceClient_PutMetrics_Call struct

+ func (_c *MockDataReceiverServiceClient_PutMetrics_Call) Return(_a0 *StatusResult, _a1 error) *MockDataReceiverServiceClient_PutMetrics_Call

+ func (_c *MockDataReceiverServiceClient_PutMetrics_Call) Run(run func(ctx context.Context, in *Metrics, opts ...grpc.CallOption)) *MockDataReceiverServiceClient_PutMetrics_Call

+ type MockDataReceiverServiceClient_PutModels_Call struct

+ func (_c *MockDataReceiverServiceClient_PutModels_Call) Return(_a0 *ModelStatusResult, _a1 error) *MockDataReceiverServiceClient_PutModels_Call

+ func (_c *MockDataReceiverServiceClient_PutModels_Call) Run(run func(ctx context.Context, in *Models, opts ...grpc.CallOption)) *MockDataReceiverServiceClient_PutModels_Call

type MockDataReceiverServiceServer

+ func NewMockDataReceiverServiceServer(t testing.TB) *MockDataReceiverServiceServer

+ func (_m *MockDataReceiverServiceServer) EXPECT() *MockDataReceiverServiceServer_Expecter

+ type MockDataReceiverServiceServer_Expecter struct

+ func (_e *MockDataReceiverServiceServer_Expecter) PutEvent(_a0 interface{}) *MockDataReceiverServiceServer_PutEvent_Call

+ func (_e *MockDataReceiverServiceServer_Expecter) PutEvents(_a0 interface{}, _a1 interface{}) *MockDataReceiverServiceServer_PutEvents_Call

+ func (_e *MockDataReceiverServiceServer_Expecter) PutMetric(_a0 interface{}) *MockDataReceiverServiceServer_PutMetric_Call

+ func (_e *MockDataReceiverServiceServer_Expecter) PutMetrics(_a0 interface{}, _a1 interface{}) *MockDataReceiverServiceServer_PutMetrics_Call

+ func (_e *MockDataReceiverServiceServer_Expecter) PutModels(_a0 interface{}, _a1 interface{}) *MockDataReceiverServiceServer_PutModels_Call

+ type MockDataReceiverServiceServer_PutEvent_Call struct

+ func (_c *MockDataReceiverServiceServer_PutEvent_Call) Return(_a0 error) *MockDataReceiverServiceServer_PutEvent_Call

+ func (_c *MockDataReceiverServiceServer_PutEvent_Call) Run(run func(_a0 DataReceiverService_PutEventServer)) *MockDataReceiverServiceServer_PutEvent_Call

+ type MockDataReceiverServiceServer_PutEvents_Call struct

+ func (_c *MockDataReceiverServiceServer_PutEvents_Call) Return(_a0 *EventStatusResult, _a1 error) *MockDataReceiverServiceServer_PutEvents_Call

+ func (_c *MockDataReceiverServiceServer_PutEvents_Call) Run(run func(_a0 context.Context, _a1 *Events)) *MockDataReceiverServiceServer_PutEvents_Call

+ type MockDataReceiverServiceServer_PutMetric_Call struct

+ func (_c *MockDataReceiverServiceServer_PutMetric_Call) Return(_a0 error) *MockDataReceiverServiceServer_PutMetric_Call

+ func (_c *MockDataReceiverServiceServer_PutMetric_Call) Run(run func(_a0 DataReceiverService_PutMetricServer)) *MockDataReceiverServiceServer_PutMetric_Call

+ type MockDataReceiverServiceServer_PutMetrics_Call struct

+ func (_c *MockDataReceiverServiceServer_PutMetrics_Call) Return(_a0 *StatusResult, _a1 error) *MockDataReceiverServiceServer_PutMetrics_Call

+ func (_c *MockDataReceiverServiceServer_PutMetrics_Call) Run(run func(_a0 context.Context, _a1 *Metrics)) *MockDataReceiverServiceServer_PutMetrics_Call

+ type MockDataReceiverServiceServer_PutModels_Call struct

+ func (_c *MockDataReceiverServiceServer_PutModels_Call) Return(_a0 *ModelStatusResult, _a1 error) *MockDataReceiverServiceServer_PutModels_Call

+ func (_c *MockDataReceiverServiceServer_PutModels_Call) Run(run func(_a0 context.Context, _a1 *Models)) *MockDataReceiverServiceServer_PutModels_Call

type MockDataReceiverService_PutEventClient

+ func NewMockDataReceiverService_PutEventClient(t testing.TB) *MockDataReceiverService_PutEventClient

+ func (_m *MockDataReceiverService_PutEventClient) EXPECT() *MockDataReceiverService_PutEventClient_Expecter

+ type MockDataReceiverService_PutEventClient_CloseAndRecv_Call struct

+ func (_c *MockDataReceiverService_PutEventClient_CloseAndRecv_Call) Return(_a0 *Void, _a1 error) *MockDataReceiverService_PutEventClient_CloseAndRecv_Call

+ func (_c *MockDataReceiverService_PutEventClient_CloseAndRecv_Call) Run(run func()) *MockDataReceiverService_PutEventClient_CloseAndRecv_Call

+ type MockDataReceiverService_PutEventClient_CloseSend_Call struct

+ func (_c *MockDataReceiverService_PutEventClient_CloseSend_Call) Return(_a0 error) *MockDataReceiverService_PutEventClient_CloseSend_Call

+ func (_c *MockDataReceiverService_PutEventClient_CloseSend_Call) Run(run func()) *MockDataReceiverService_PutEventClient_CloseSend_Call

+ type MockDataReceiverService_PutEventClient_Context_Call struct

+ func (_c *MockDataReceiverService_PutEventClient_Context_Call) Return(_a0 context.Context) *MockDataReceiverService_PutEventClient_Context_Call

+ func (_c *MockDataReceiverService_PutEventClient_Context_Call) Run(run func()) *MockDataReceiverService_PutEventClient_Context_Call

+ type MockDataReceiverService_PutEventClient_Expecter struct

+ func (_e *MockDataReceiverService_PutEventClient_Expecter) CloseAndRecv() *MockDataReceiverService_PutEventClient_CloseAndRecv_Call

+ func (_e *MockDataReceiverService_PutEventClient_Expecter) CloseSend() *MockDataReceiverService_PutEventClient_CloseSend_Call

+ func (_e *MockDataReceiverService_PutEventClient_Expecter) Context() *MockDataReceiverService_PutEventClient_Context_Call

+ func (_e *MockDataReceiverService_PutEventClient_Expecter) Header() *MockDataReceiverService_PutEventClient_Header_Call

+ func (_e *MockDataReceiverService_PutEventClient_Expecter) RecvMsg(m interface{}) *MockDataReceiverService_PutEventClient_RecvMsg_Call

+ func (_e *MockDataReceiverService_PutEventClient_Expecter) Send(_a0 interface{}) *MockDataReceiverService_PutEventClient_Send_Call

+ func (_e *MockDataReceiverService_PutEventClient_Expecter) SendMsg(m interface{}) *MockDataReceiverService_PutEventClient_SendMsg_Call

+ func (_e *MockDataReceiverService_PutEventClient_Expecter) Trailer() *MockDataReceiverService_PutEventClient_Trailer_Call

+ type MockDataReceiverService_PutEventClient_Header_Call struct

+ func (_c *MockDataReceiverService_PutEventClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *MockDataReceiverService_PutEventClient_Header_Call

+ func (_c *MockDataReceiverService_PutEventClient_Header_Call) Run(run func()) *MockDataReceiverService_PutEventClient_Header_Call

+ type MockDataReceiverService_PutEventClient_RecvMsg_Call struct

+ func (_c *MockDataReceiverService_PutEventClient_RecvMsg_Call) Return(_a0 error) *MockDataReceiverService_PutEventClient_RecvMsg_Call

+ func (_c *MockDataReceiverService_PutEventClient_RecvMsg_Call) Run(run func(m interface{})) *MockDataReceiverService_PutEventClient_RecvMsg_Call

+ type MockDataReceiverService_PutEventClient_SendMsg_Call struct

+ func (_c *MockDataReceiverService_PutEventClient_SendMsg_Call) Return(_a0 error) *MockDataReceiverService_PutEventClient_SendMsg_Call

+ func (_c *MockDataReceiverService_PutEventClient_SendMsg_Call) Run(run func(m interface{})) *MockDataReceiverService_PutEventClient_SendMsg_Call

+ type MockDataReceiverService_PutEventClient_Send_Call struct

+ func (_c *MockDataReceiverService_PutEventClient_Send_Call) Return(_a0 error) *MockDataReceiverService_PutEventClient_Send_Call

+ func (_c *MockDataReceiverService_PutEventClient_Send_Call) Run(run func(_a0 *EventWrapper)) *MockDataReceiverService_PutEventClient_Send_Call

+ type MockDataReceiverService_PutEventClient_Trailer_Call struct

+ func (_c *MockDataReceiverService_PutEventClient_Trailer_Call) Return(_a0 metadata.MD) *MockDataReceiverService_PutEventClient_Trailer_Call

+ func (_c *MockDataReceiverService_PutEventClient_Trailer_Call) Run(run func()) *MockDataReceiverService_PutEventClient_Trailer_Call

type MockDataReceiverService_PutEventServer

+ func NewMockDataReceiverService_PutEventServer(t testing.TB) *MockDataReceiverService_PutEventServer

+ func (_m *MockDataReceiverService_PutEventServer) EXPECT() *MockDataReceiverService_PutEventServer_Expecter

+ type MockDataReceiverService_PutEventServer_Context_Call struct

+ func (_c *MockDataReceiverService_PutEventServer_Context_Call) Return(_a0 context.Context) *MockDataReceiverService_PutEventServer_Context_Call

+ func (_c *MockDataReceiverService_PutEventServer_Context_Call) Run(run func()) *MockDataReceiverService_PutEventServer_Context_Call

+ type MockDataReceiverService_PutEventServer_Expecter struct

+ func (_e *MockDataReceiverService_PutEventServer_Expecter) Context() *MockDataReceiverService_PutEventServer_Context_Call

+ func (_e *MockDataReceiverService_PutEventServer_Expecter) Recv() *MockDataReceiverService_PutEventServer_Recv_Call

+ func (_e *MockDataReceiverService_PutEventServer_Expecter) RecvMsg(m interface{}) *MockDataReceiverService_PutEventServer_RecvMsg_Call

+ func (_e *MockDataReceiverService_PutEventServer_Expecter) SendAndClose(_a0 interface{}) *MockDataReceiverService_PutEventServer_SendAndClose_Call

+ func (_e *MockDataReceiverService_PutEventServer_Expecter) SendHeader(_a0 interface{}) *MockDataReceiverService_PutEventServer_SendHeader_Call

+ func (_e *MockDataReceiverService_PutEventServer_Expecter) SendMsg(m interface{}) *MockDataReceiverService_PutEventServer_SendMsg_Call

+ func (_e *MockDataReceiverService_PutEventServer_Expecter) SetHeader(_a0 interface{}) *MockDataReceiverService_PutEventServer_SetHeader_Call

+ func (_e *MockDataReceiverService_PutEventServer_Expecter) SetTrailer(_a0 interface{}) *MockDataReceiverService_PutEventServer_SetTrailer_Call

+ type MockDataReceiverService_PutEventServer_RecvMsg_Call struct

+ func (_c *MockDataReceiverService_PutEventServer_RecvMsg_Call) Return(_a0 error) *MockDataReceiverService_PutEventServer_RecvMsg_Call

+ func (_c *MockDataReceiverService_PutEventServer_RecvMsg_Call) Run(run func(m interface{})) *MockDataReceiverService_PutEventServer_RecvMsg_Call

+ type MockDataReceiverService_PutEventServer_Recv_Call struct

+ func (_c *MockDataReceiverService_PutEventServer_Recv_Call) Return(_a0 *EventWrapper, _a1 error) *MockDataReceiverService_PutEventServer_Recv_Call

+ func (_c *MockDataReceiverService_PutEventServer_Recv_Call) Run(run func()) *MockDataReceiverService_PutEventServer_Recv_Call

+ type MockDataReceiverService_PutEventServer_SendAndClose_Call struct

+ func (_c *MockDataReceiverService_PutEventServer_SendAndClose_Call) Return(_a0 error) *MockDataReceiverService_PutEventServer_SendAndClose_Call

+ func (_c *MockDataReceiverService_PutEventServer_SendAndClose_Call) Run(run func(_a0 *Void)) *MockDataReceiverService_PutEventServer_SendAndClose_Call

+ type MockDataReceiverService_PutEventServer_SendHeader_Call struct

+ func (_c *MockDataReceiverService_PutEventServer_SendHeader_Call) Return(_a0 error) *MockDataReceiverService_PutEventServer_SendHeader_Call

+ func (_c *MockDataReceiverService_PutEventServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *MockDataReceiverService_PutEventServer_SendHeader_Call

+ type MockDataReceiverService_PutEventServer_SendMsg_Call struct

+ func (_c *MockDataReceiverService_PutEventServer_SendMsg_Call) Return(_a0 error) *MockDataReceiverService_PutEventServer_SendMsg_Call

+ func (_c *MockDataReceiverService_PutEventServer_SendMsg_Call) Run(run func(m interface{})) *MockDataReceiverService_PutEventServer_SendMsg_Call

+ type MockDataReceiverService_PutEventServer_SetHeader_Call struct

+ func (_c *MockDataReceiverService_PutEventServer_SetHeader_Call) Return(_a0 error) *MockDataReceiverService_PutEventServer_SetHeader_Call

+ func (_c *MockDataReceiverService_PutEventServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *MockDataReceiverService_PutEventServer_SetHeader_Call

+ type MockDataReceiverService_PutEventServer_SetTrailer_Call struct

+ func (_c *MockDataReceiverService_PutEventServer_SetTrailer_Call) Return() *MockDataReceiverService_PutEventServer_SetTrailer_Call

+ func (_c *MockDataReceiverService_PutEventServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *MockDataReceiverService_PutEventServer_SetTrailer_Call

type MockDataReceiverService_PutMetricClient

+ func NewMockDataReceiverService_PutMetricClient(t testing.TB) *MockDataReceiverService_PutMetricClient

+ func (_m *MockDataReceiverService_PutMetricClient) EXPECT() *MockDataReceiverService_PutMetricClient_Expecter

+ type MockDataReceiverService_PutMetricClient_CloseAndRecv_Call struct

+ func (_c *MockDataReceiverService_PutMetricClient_CloseAndRecv_Call) Return(_a0 *Void, _a1 error) *MockDataReceiverService_PutMetricClient_CloseAndRecv_Call

+ func (_c *MockDataReceiverService_PutMetricClient_CloseAndRecv_Call) Run(run func()) *MockDataReceiverService_PutMetricClient_CloseAndRecv_Call

+ type MockDataReceiverService_PutMetricClient_CloseSend_Call struct

+ func (_c *MockDataReceiverService_PutMetricClient_CloseSend_Call) Return(_a0 error) *MockDataReceiverService_PutMetricClient_CloseSend_Call

+ func (_c *MockDataReceiverService_PutMetricClient_CloseSend_Call) Run(run func()) *MockDataReceiverService_PutMetricClient_CloseSend_Call

+ type MockDataReceiverService_PutMetricClient_Context_Call struct

+ func (_c *MockDataReceiverService_PutMetricClient_Context_Call) Return(_a0 context.Context) *MockDataReceiverService_PutMetricClient_Context_Call

+ func (_c *MockDataReceiverService_PutMetricClient_Context_Call) Run(run func()) *MockDataReceiverService_PutMetricClient_Context_Call

+ type MockDataReceiverService_PutMetricClient_Expecter struct

+ func (_e *MockDataReceiverService_PutMetricClient_Expecter) CloseAndRecv() *MockDataReceiverService_PutMetricClient_CloseAndRecv_Call

+ func (_e *MockDataReceiverService_PutMetricClient_Expecter) CloseSend() *MockDataReceiverService_PutMetricClient_CloseSend_Call

+ func (_e *MockDataReceiverService_PutMetricClient_Expecter) Context() *MockDataReceiverService_PutMetricClient_Context_Call

+ func (_e *MockDataReceiverService_PutMetricClient_Expecter) Header() *MockDataReceiverService_PutMetricClient_Header_Call

+ func (_e *MockDataReceiverService_PutMetricClient_Expecter) RecvMsg(m interface{}) *MockDataReceiverService_PutMetricClient_RecvMsg_Call

+ func (_e *MockDataReceiverService_PutMetricClient_Expecter) Send(_a0 interface{}) *MockDataReceiverService_PutMetricClient_Send_Call

+ func (_e *MockDataReceiverService_PutMetricClient_Expecter) SendMsg(m interface{}) *MockDataReceiverService_PutMetricClient_SendMsg_Call

+ func (_e *MockDataReceiverService_PutMetricClient_Expecter) Trailer() *MockDataReceiverService_PutMetricClient_Trailer_Call

+ type MockDataReceiverService_PutMetricClient_Header_Call struct

+ func (_c *MockDataReceiverService_PutMetricClient_Header_Call) Return(_a0 metadata.MD, _a1 error) *MockDataReceiverService_PutMetricClient_Header_Call

+ func (_c *MockDataReceiverService_PutMetricClient_Header_Call) Run(run func()) *MockDataReceiverService_PutMetricClient_Header_Call

+ type MockDataReceiverService_PutMetricClient_RecvMsg_Call struct

+ func (_c *MockDataReceiverService_PutMetricClient_RecvMsg_Call) Return(_a0 error) *MockDataReceiverService_PutMetricClient_RecvMsg_Call

+ func (_c *MockDataReceiverService_PutMetricClient_RecvMsg_Call) Run(run func(m interface{})) *MockDataReceiverService_PutMetricClient_RecvMsg_Call

+ type MockDataReceiverService_PutMetricClient_SendMsg_Call struct

+ func (_c *MockDataReceiverService_PutMetricClient_SendMsg_Call) Return(_a0 error) *MockDataReceiverService_PutMetricClient_SendMsg_Call

+ func (_c *MockDataReceiverService_PutMetricClient_SendMsg_Call) Run(run func(m interface{})) *MockDataReceiverService_PutMetricClient_SendMsg_Call

+ type MockDataReceiverService_PutMetricClient_Send_Call struct

+ func (_c *MockDataReceiverService_PutMetricClient_Send_Call) Return(_a0 error) *MockDataReceiverService_PutMetricClient_Send_Call

+ func (_c *MockDataReceiverService_PutMetricClient_Send_Call) Run(run func(_a0 *MetricWrapper)) *MockDataReceiverService_PutMetricClient_Send_Call

+ type MockDataReceiverService_PutMetricClient_Trailer_Call struct

+ func (_c *MockDataReceiverService_PutMetricClient_Trailer_Call) Return(_a0 metadata.MD) *MockDataReceiverService_PutMetricClient_Trailer_Call

+ func (_c *MockDataReceiverService_PutMetricClient_Trailer_Call) Run(run func()) *MockDataReceiverService_PutMetricClient_Trailer_Call

type MockDataReceiverService_PutMetricServer

+ func NewMockDataReceiverService_PutMetricServer(t testing.TB) *MockDataReceiverService_PutMetricServer

+ func (_m *MockDataReceiverService_PutMetricServer) EXPECT() *MockDataReceiverService_PutMetricServer_Expecter

+ type MockDataReceiverService_PutMetricServer_Context_Call struct

+ func (_c *MockDataReceiverService_PutMetricServer_Context_Call) Return(_a0 context.Context) *MockDataReceiverService_PutMetricServer_Context_Call

+ func (_c *MockDataReceiverService_PutMetricServer_Context_Call) Run(run func()) *MockDataReceiverService_PutMetricServer_Context_Call

+ type MockDataReceiverService_PutMetricServer_Expecter struct

+ func (_e *MockDataReceiverService_PutMetricServer_Expecter) Context() *MockDataReceiverService_PutMetricServer_Context_Call

+ func (_e *MockDataReceiverService_PutMetricServer_Expecter) Recv() *MockDataReceiverService_PutMetricServer_Recv_Call

+ func (_e *MockDataReceiverService_PutMetricServer_Expecter) RecvMsg(m interface{}) *MockDataReceiverService_PutMetricServer_RecvMsg_Call

+ func (_e *MockDataReceiverService_PutMetricServer_Expecter) SendAndClose(_a0 interface{}) *MockDataReceiverService_PutMetricServer_SendAndClose_Call

+ func (_e *MockDataReceiverService_PutMetricServer_Expecter) SendHeader(_a0 interface{}) *MockDataReceiverService_PutMetricServer_SendHeader_Call

+ func (_e *MockDataReceiverService_PutMetricServer_Expecter) SendMsg(m interface{}) *MockDataReceiverService_PutMetricServer_SendMsg_Call

+ func (_e *MockDataReceiverService_PutMetricServer_Expecter) SetHeader(_a0 interface{}) *MockDataReceiverService_PutMetricServer_SetHeader_Call

+ func (_e *MockDataReceiverService_PutMetricServer_Expecter) SetTrailer(_a0 interface{}) *MockDataReceiverService_PutMetricServer_SetTrailer_Call

+ type MockDataReceiverService_PutMetricServer_RecvMsg_Call struct

+ func (_c *MockDataReceiverService_PutMetricServer_RecvMsg_Call) Return(_a0 error) *MockDataReceiverService_PutMetricServer_RecvMsg_Call

+ func (_c *MockDataReceiverService_PutMetricServer_RecvMsg_Call) Run(run func(m interface{})) *MockDataReceiverService_PutMetricServer_RecvMsg_Call

+ type MockDataReceiverService_PutMetricServer_Recv_Call struct

+ func (_c *MockDataReceiverService_PutMetricServer_Recv_Call) Return(_a0 *MetricWrapper, _a1 error) *MockDataReceiverService_PutMetricServer_Recv_Call

+ func (_c *MockDataReceiverService_PutMetricServer_Recv_Call) Run(run func()) *MockDataReceiverService_PutMetricServer_Recv_Call

+ type MockDataReceiverService_PutMetricServer_SendAndClose_Call struct

+ func (_c *MockDataReceiverService_PutMetricServer_SendAndClose_Call) Return(_a0 error) *MockDataReceiverService_PutMetricServer_SendAndClose_Call

+ func (_c *MockDataReceiverService_PutMetricServer_SendAndClose_Call) Run(run func(_a0 *Void)) *MockDataReceiverService_PutMetricServer_SendAndClose_Call

+ type MockDataReceiverService_PutMetricServer_SendHeader_Call struct

+ func (_c *MockDataReceiverService_PutMetricServer_SendHeader_Call) Return(_a0 error) *MockDataReceiverService_PutMetricServer_SendHeader_Call

+ func (_c *MockDataReceiverService_PutMetricServer_SendHeader_Call) Run(run func(_a0 metadata.MD)) *MockDataReceiverService_PutMetricServer_SendHeader_Call

+ type MockDataReceiverService_PutMetricServer_SendMsg_Call struct

+ func (_c *MockDataReceiverService_PutMetricServer_SendMsg_Call) Return(_a0 error) *MockDataReceiverService_PutMetricServer_SendMsg_Call

+ func (_c *MockDataReceiverService_PutMetricServer_SendMsg_Call) Run(run func(m interface{})) *MockDataReceiverService_PutMetricServer_SendMsg_Call

+ type MockDataReceiverService_PutMetricServer_SetHeader_Call struct

+ func (_c *MockDataReceiverService_PutMetricServer_SetHeader_Call) Return(_a0 error) *MockDataReceiverService_PutMetricServer_SetHeader_Call

+ func (_c *MockDataReceiverService_PutMetricServer_SetHeader_Call) Run(run func(_a0 metadata.MD)) *MockDataReceiverService_PutMetricServer_SetHeader_Call

+ type MockDataReceiverService_PutMetricServer_SetTrailer_Call struct

+ func (_c *MockDataReceiverService_PutMetricServer_SetTrailer_Call) Return() *MockDataReceiverService_PutMetricServer_SetTrailer_Call

+ func (_c *MockDataReceiverService_PutMetricServer_SetTrailer_Call) Run(run func(_a0 metadata.MD)) *MockDataReceiverService_PutMetricServer_SetTrailer_Call

type Model

+ func (x *Model) ProtoReflect() protoreflect.Message

type ModelError

+ func (x *ModelError) ProtoReflect() protoreflect.Message

type ModelStatusResult

+ func (x *ModelStatusResult) ProtoReflect() protoreflect.Message

type Models

+ func (x *Models) ProtoReflect() protoreflect.Message

type Severity

+ func (Severity) Descriptor() protoreflect.EnumDescriptor

+ func (Severity) Type() protoreflect.EnumType

+ func (x Severity) Enum() *Severity

+ func (x Severity) Number() protoreflect.EnumNumber

type Status

+ func (Status) Descriptor() protoreflect.EnumDescriptor

+ func (Status) Type() protoreflect.EnumType

+ func (x Status) Enum() *Status

+ func (x Status) Number() protoreflect.EnumNumber

type StatusResult

+ func (x *StatusResult) ProtoReflect() protoreflect.Message

type TaggedMetric

+ func (x *TaggedMetric) ProtoReflect() protoreflect.Message

type TaggedMetricError

+ func (x *TaggedMetricError) ProtoReflect() protoreflect.Message

type Void

+ func (x *Void) ProtoReflect() protoreflect.Message

v1.3.0

Mar 24, 2022

v1.2.0

Mar 30, 2021

v1.1.0

Jul 1, 2020

Changes in this version

+ var Severity_name = map[int32]string

+ var Severity_value = map[string]int32

+ var Status_name = map[int32]string

+ var Status_value = map[string]int32

type DataReceiverServiceClient

+ PutEvent func(ctx context.Context, opts ...grpc.CallOption) (DataReceiverService_PutEventClient, error)

+ PutEvents func(ctx context.Context, in *Events, opts ...grpc.CallOption) (*EventStatusResult, error)

type DataReceiverServiceServer

+ PutEvent func(DataReceiverService_PutEventServer) error

+ PutEvents func(context.Context, *Events) (*EventStatusResult, error)

+ type DataReceiverService_PutEventClient interface

+ CloseAndRecv func() (*Void, error)

+ Send func(*EventWrapper) error

+ type DataReceiverService_PutEventServer interface

+ Recv func() (*EventWrapper, error)

+ SendAndClose func(*Void) error

+ type Event struct

+ Acknowledged *wrappers.BoolValue

+ Body string

+ Dimensions map[string]string

+ MetadataFields *_struct.Struct

+ Name string

+ Severity Severity

+ Status Status

+ Summary string

+ Timestamp int64

+ Type string

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*Event) Descriptor() ([]byte, []int)

+ func (*Event) ProtoMessage()

+ func (m *Event) GetAcknowledged() *wrappers.BoolValue

+ func (m *Event) GetBody() string

+ func (m *Event) GetDimensions() map[string]string

+ func (m *Event) GetMetadataFields() *_struct.Struct

+ func (m *Event) GetName() string

+ func (m *Event) GetSeverity() Severity

+ func (m *Event) GetStatus() Status

+ func (m *Event) GetSummary() string

+ func (m *Event) GetTimestamp() int64

+ func (m *Event) GetType() string

+ func (m *Event) Reset()

+ func (m *Event) String() string

+ func (m *Event) XXX_DiscardUnknown()

+ func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Event) XXX_Merge(src proto.Message)

+ func (m *Event) XXX_Size() int

+ func (m *Event) XXX_Unmarshal(b []byte) error

+ type EventError struct

+ Error string

+ Event *Event

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*EventError) Descriptor() ([]byte, []int)

+ func (*EventError) ProtoMessage()

+ func (m *EventError) GetError() string

+ func (m *EventError) GetEvent() *Event

+ func (m *EventError) Reset()

+ func (m *EventError) String() string

+ func (m *EventError) XXX_DiscardUnknown()

+ func (m *EventError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *EventError) XXX_Merge(src proto.Message)

+ func (m *EventError) XXX_Size() int

+ func (m *EventError) XXX_Unmarshal(b []byte) error

+ type EventStatusResult struct

+ Failed int32

+ FailedEvents []*EventError

+ Message string

+ Succeeded int32

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*EventStatusResult) Descriptor() ([]byte, []int)

+ func (*EventStatusResult) ProtoMessage()

+ func (m *EventStatusResult) GetFailed() int32

+ func (m *EventStatusResult) GetFailedEvents() []*EventError

+ func (m *EventStatusResult) GetMessage() string

+ func (m *EventStatusResult) GetSucceeded() int32

+ func (m *EventStatusResult) Reset()

+ func (m *EventStatusResult) String() string

+ func (m *EventStatusResult) XXX_DiscardUnknown()

+ func (m *EventStatusResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *EventStatusResult) XXX_Merge(src proto.Message)

+ func (m *EventStatusResult) XXX_Size() int

+ func (m *EventStatusResult) XXX_Unmarshal(b []byte) error

+ type EventWrapper struct

+ EventType isEventWrapper_EventType

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*EventWrapper) Descriptor() ([]byte, []int)

+ func (*EventWrapper) ProtoMessage()

+ func (*EventWrapper) XXX_OneofWrappers() []interface{}

+ func (m *EventWrapper) GetCanonical() *Event

+ func (m *EventWrapper) GetEventType() isEventWrapper_EventType

+ func (m *EventWrapper) Reset()

+ func (m *EventWrapper) String() string

+ func (m *EventWrapper) XXX_DiscardUnknown()

+ func (m *EventWrapper) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *EventWrapper) XXX_Merge(src proto.Message)

+ func (m *EventWrapper) XXX_Size() int

+ func (m *EventWrapper) XXX_Unmarshal(b []byte) error

+ type EventWrapper_Canonical struct

+ Canonical *Event

+ type Events struct

+ DetailedResponse bool

+ Events []*Event

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*Events) Descriptor() ([]byte, []int)

+ func (*Events) ProtoMessage()

+ func (m *Events) GetDetailedResponse() bool

+ func (m *Events) GetEvents() []*Event

+ func (m *Events) Reset()

+ func (m *Events) String() string

+ func (m *Events) XXX_DiscardUnknown()

+ func (m *Events) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Events) XXX_Merge(src proto.Message)

+ func (m *Events) XXX_Size() int

+ func (m *Events) XXX_Unmarshal(b []byte) error

type MockDataReceiverServiceClient

+ func (_m *MockDataReceiverServiceClient) PutEvent(ctx context.Context, opts ...grpc.CallOption) (DataReceiverService_PutEventClient, error)

+ func (_m *MockDataReceiverServiceClient) PutEvents(ctx context.Context, in *Events, opts ...grpc.CallOption) (*EventStatusResult, error)

type MockDataReceiverServiceServer

+ func (_m *MockDataReceiverServiceServer) PutEvent(_a0 DataReceiverService_PutEventServer) error

+ func (_m *MockDataReceiverServiceServer) PutEvents(_a0 context.Context, _a1 *Events) (*EventStatusResult, error)

+ type MockDataReceiverService_PutEventClient struct

+ func (_m *MockDataReceiverService_PutEventClient) CloseAndRecv() (*Void, error)

+ func (_m *MockDataReceiverService_PutEventClient) CloseSend() error

+ func (_m *MockDataReceiverService_PutEventClient) Context() context.Context

+ func (_m *MockDataReceiverService_PutEventClient) Header() (metadata.MD, error)

+ func (_m *MockDataReceiverService_PutEventClient) RecvMsg(m interface{}) error

+ func (_m *MockDataReceiverService_PutEventClient) Send(_a0 *EventWrapper) error

+ func (_m *MockDataReceiverService_PutEventClient) SendMsg(m interface{}) error

+ func (_m *MockDataReceiverService_PutEventClient) Trailer() metadata.MD

+ type MockDataReceiverService_PutEventServer struct

+ func (_m *MockDataReceiverService_PutEventServer) Context() context.Context

+ func (_m *MockDataReceiverService_PutEventServer) Recv() (*EventWrapper, error)

+ func (_m *MockDataReceiverService_PutEventServer) RecvMsg(m interface{}) error

+ func (_m *MockDataReceiverService_PutEventServer) SendAndClose(_a0 *Void) error

+ func (_m *MockDataReceiverService_PutEventServer) SendHeader(_a0 metadata.MD) error

+ func (_m *MockDataReceiverService_PutEventServer) SendMsg(m interface{}) error

+ func (_m *MockDataReceiverService_PutEventServer) SetHeader(_a0 metadata.MD) error

+ func (_m *MockDataReceiverService_PutEventServer) SetTrailer(_a0 metadata.MD)

+ type Severity int32

+ const Severity_SEVERITY_CRITICAL

+ const Severity_SEVERITY_DEBUG

+ const Severity_SEVERITY_DEFAULT

+ const Severity_SEVERITY_ERROR

+ const Severity_SEVERITY_INFO

+ const Severity_SEVERITY_WARNING

+ func (Severity) EnumDescriptor() ([]byte, []int)

+ func (x Severity) String() string

+ type Status int32

+ const Status_STATUS_CLOSED

+ const Status_STATUS_DEFAULT

+ const Status_STATUS_OPEN

+ const Status_STATUS_SUPPRESSED

+ func (Status) EnumDescriptor() ([]byte, []int)

+ func (x Status) String() string

type UnimplementedDataReceiverServiceServer

+ func (*UnimplementedDataReceiverServiceServer) PutEvent(srv DataReceiverService_PutEventServer) error

+ func (*UnimplementedDataReceiverServiceServer) PutEvents(ctx context.Context, req *Events) (*EventStatusResult, error)

v1.0.0

Apr 7, 2020

Changes in this version

+ func RegisterDataReceiverServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

+ func RegisterDataReceiverServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client DataReceiverServiceClient) error

+ func RegisterDataReceiverServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, ...) (err error)

+ func RegisterDataReceiverServiceServer(s *grpc.Server, srv DataReceiverServiceServer)

+ type CompactMetric struct

+ Id string

+ Timestamp int64

+ Value float64

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*CompactMetric) Descriptor() ([]byte, []int)

+ func (*CompactMetric) ProtoMessage()

+ func (m *CompactMetric) GetId() string

+ func (m *CompactMetric) GetTimestamp() int64

+ func (m *CompactMetric) GetValue() float64

+ func (m *CompactMetric) Reset()

+ func (m *CompactMetric) String() string

+ func (m *CompactMetric) XXX_DiscardUnknown()

+ func (m *CompactMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *CompactMetric) XXX_Merge(src proto.Message)

+ func (m *CompactMetric) XXX_Size() int

+ func (m *CompactMetric) XXX_Unmarshal(b []byte) error

+ type CompactMetricError struct

+ Error string

+ Metric *CompactMetric

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*CompactMetricError) Descriptor() ([]byte, []int)

+ func (*CompactMetricError) ProtoMessage()

+ func (m *CompactMetricError) GetError() string

+ func (m *CompactMetricError) GetMetric() *CompactMetric

+ func (m *CompactMetricError) Reset()

+ func (m *CompactMetricError) String() string

+ func (m *CompactMetricError) XXX_DiscardUnknown()

+ func (m *CompactMetricError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *CompactMetricError) XXX_Merge(src proto.Message)

+ func (m *CompactMetricError) XXX_Size() int

+ func (m *CompactMetricError) XXX_Unmarshal(b []byte) error

+ type DataReceiverServiceClient interface

+ PutMetric func(ctx context.Context, opts ...grpc.CallOption) (DataReceiverService_PutMetricClient, error)

+ PutMetrics func(ctx context.Context, in *Metrics, opts ...grpc.CallOption) (*StatusResult, error)

+ PutModels func(ctx context.Context, in *Models, opts ...grpc.CallOption) (*ModelStatusResult, error)

+ func NewDataReceiverServiceClient(cc *grpc.ClientConn) DataReceiverServiceClient

+ type DataReceiverServiceServer interface

+ PutMetric func(DataReceiverService_PutMetricServer) error

+ PutMetrics func(context.Context, *Metrics) (*StatusResult, error)

+ PutModels func(context.Context, *Models) (*ModelStatusResult, error)

+ type DataReceiverService_PutMetricClient interface

+ CloseAndRecv func() (*Void, error)

+ Send func(*MetricWrapper) error

+ type DataReceiverService_PutMetricServer interface

+ Recv func() (*MetricWrapper, error)

+ SendAndClose func(*Void) error

+ type Metric struct

+ Dimensions map[string]string

+ MetadataFields *_struct.Struct

+ Metric string

+ Timestamp int64

+ Value float64

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*Metric) Descriptor() ([]byte, []int)

+ func (*Metric) ProtoMessage()

+ func (m *Metric) GetDimensions() map[string]string

+ func (m *Metric) GetMetadataFields() *_struct.Struct

+ func (m *Metric) GetMetric() string

+ func (m *Metric) GetTimestamp() int64

+ func (m *Metric) GetValue() float64

+ func (m *Metric) Reset()

+ func (m *Metric) String() string

+ func (m *Metric) XXX_DiscardUnknown()

+ func (m *Metric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Metric) XXX_Merge(src proto.Message)

+ func (m *Metric) XXX_Size() int

+ func (m *Metric) XXX_Unmarshal(b []byte) error

+ type MetricBatch struct

+ GlobalTags map[string]string

+ Metrics []*MetricWrapper

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*MetricBatch) Descriptor() ([]byte, []int)

+ func (*MetricBatch) ProtoMessage()

+ func (m *MetricBatch) GetGlobalTags() map[string]string

+ func (m *MetricBatch) GetMetrics() []*MetricWrapper

+ func (m *MetricBatch) Reset()

+ func (m *MetricBatch) String() string

+ func (m *MetricBatch) XXX_DiscardUnknown()

+ func (m *MetricBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *MetricBatch) XXX_Merge(src proto.Message)

+ func (m *MetricBatch) XXX_Size() int

+ func (m *MetricBatch) XXX_Unmarshal(b []byte) error

+ type MetricError struct

+ Error string

+ Metric *Metric

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*MetricError) Descriptor() ([]byte, []int)

+ func (*MetricError) ProtoMessage()

+ func (m *MetricError) GetError() string

+ func (m *MetricError) GetMetric() *Metric

+ func (m *MetricError) Reset()

+ func (m *MetricError) String() string

+ func (m *MetricError) XXX_DiscardUnknown()

+ func (m *MetricError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *MetricError) XXX_Merge(src proto.Message)

+ func (m *MetricError) XXX_Size() int

+ func (m *MetricError) XXX_Unmarshal(b []byte) error

+ type MetricWrapper struct

+ MetricType isMetricWrapper_MetricType

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*MetricWrapper) Descriptor() ([]byte, []int)

+ func (*MetricWrapper) ProtoMessage()

+ func (*MetricWrapper) XXX_OneofWrappers() []interface{}

+ func (m *MetricWrapper) GetCanonical() *Metric

+ func (m *MetricWrapper) GetCompact() *CompactMetric

+ func (m *MetricWrapper) GetMetricType() isMetricWrapper_MetricType

+ func (m *MetricWrapper) GetTagged() *TaggedMetric

+ func (m *MetricWrapper) Reset()

+ func (m *MetricWrapper) String() string

+ func (m *MetricWrapper) XXX_DiscardUnknown()

+ func (m *MetricWrapper) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *MetricWrapper) XXX_Merge(src proto.Message)

+ func (m *MetricWrapper) XXX_Size() int

+ func (m *MetricWrapper) XXX_Unmarshal(b []byte) error

+ type MetricWrapper_Canonical struct

+ Canonical *Metric

+ type MetricWrapper_Compact struct

+ Compact *CompactMetric

+ type MetricWrapper_Tagged struct

+ Tagged *TaggedMetric

+ type Metrics struct

+ CompactMetrics []*CompactMetric

+ DetailedResponse bool

+ Metrics []*Metric

+ TaggedMetrics []*TaggedMetric

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*Metrics) Descriptor() ([]byte, []int)

+ func (*Metrics) ProtoMessage()

+ func (m *Metrics) GetCompactMetrics() []*CompactMetric

+ func (m *Metrics) GetDetailedResponse() bool

+ func (m *Metrics) GetMetrics() []*Metric

+ func (m *Metrics) GetTaggedMetrics() []*TaggedMetric

+ func (m *Metrics) Reset()

+ func (m *Metrics) String() string

+ func (m *Metrics) XXX_DiscardUnknown()

+ func (m *Metrics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Metrics) XXX_Merge(src proto.Message)

+ func (m *Metrics) XXX_Size() int

+ func (m *Metrics) XXX_Unmarshal(b []byte) error

+ type MockDataReceiverServiceClient struct

+ func (_m *MockDataReceiverServiceClient) PutMetric(ctx context.Context, opts ...grpc.CallOption) (DataReceiverService_PutMetricClient, error)

+ func (_m *MockDataReceiverServiceClient) PutMetrics(ctx context.Context, in *Metrics, opts ...grpc.CallOption) (*StatusResult, error)

+ func (_m *MockDataReceiverServiceClient) PutModels(ctx context.Context, in *Models, opts ...grpc.CallOption) (*ModelStatusResult, error)

+ type MockDataReceiverServiceServer struct

+ func (_m *MockDataReceiverServiceServer) PutMetric(_a0 DataReceiverService_PutMetricServer) error

+ func (_m *MockDataReceiverServiceServer) PutMetrics(_a0 context.Context, _a1 *Metrics) (*StatusResult, error)

+ func (_m *MockDataReceiverServiceServer) PutModels(_a0 context.Context, _a1 *Models) (*ModelStatusResult, error)

+ type MockDataReceiverService_PutMetricClient struct

+ func (_m *MockDataReceiverService_PutMetricClient) CloseAndRecv() (*Void, error)

+ func (_m *MockDataReceiverService_PutMetricClient) CloseSend() error

+ func (_m *MockDataReceiverService_PutMetricClient) Context() context.Context

+ func (_m *MockDataReceiverService_PutMetricClient) Header() (metadata.MD, error)

+ func (_m *MockDataReceiverService_PutMetricClient) RecvMsg(m interface{}) error

+ func (_m *MockDataReceiverService_PutMetricClient) Send(_a0 *MetricWrapper) error

+ func (_m *MockDataReceiverService_PutMetricClient) SendMsg(m interface{}) error

+ func (_m *MockDataReceiverService_PutMetricClient) Trailer() metadata.MD

+ type MockDataReceiverService_PutMetricServer struct

+ func (_m *MockDataReceiverService_PutMetricServer) Context() context.Context

+ func (_m *MockDataReceiverService_PutMetricServer) Recv() (*MetricWrapper, error)

+ func (_m *MockDataReceiverService_PutMetricServer) RecvMsg(m interface{}) error

+ func (_m *MockDataReceiverService_PutMetricServer) SendAndClose(_a0 *Void) error

+ func (_m *MockDataReceiverService_PutMetricServer) SendHeader(_a0 metadata.MD) error

+ func (_m *MockDataReceiverService_PutMetricServer) SendMsg(m interface{}) error

+ func (_m *MockDataReceiverService_PutMetricServer) SetHeader(_a0 metadata.MD) error

+ func (_m *MockDataReceiverService_PutMetricServer) SetTrailer(_a0 metadata.MD)

+ type Model struct

+ Dimensions map[string]string

+ MetadataFields *_struct.Struct

+ Timestamp int64

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*Model) Descriptor() ([]byte, []int)

+ func (*Model) ProtoMessage()

+ func (m *Model) GetDimensions() map[string]string

+ func (m *Model) GetMetadataFields() *_struct.Struct

+ func (m *Model) GetTimestamp() int64

+ func (m *Model) Reset()

+ func (m *Model) String() string

+ func (m *Model) XXX_DiscardUnknown()

+ func (m *Model) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Model) XXX_Merge(src proto.Message)

+ func (m *Model) XXX_Size() int

+ func (m *Model) XXX_Unmarshal(b []byte) error

+ type ModelError struct

+ Error string

+ Model *Model

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*ModelError) Descriptor() ([]byte, []int)

+ func (*ModelError) ProtoMessage()

+ func (m *ModelError) GetError() string

+ func (m *ModelError) GetModel() *Model

+ func (m *ModelError) Reset()

+ func (m *ModelError) String() string

+ func (m *ModelError) XXX_DiscardUnknown()

+ func (m *ModelError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *ModelError) XXX_Merge(src proto.Message)

+ func (m *ModelError) XXX_Size() int

+ func (m *ModelError) XXX_Unmarshal(b []byte) error

+ type ModelStatusResult struct

+ Failed int32

+ FailedModels []*ModelError

+ Message string

+ Succeeded int32

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*ModelStatusResult) Descriptor() ([]byte, []int)

+ func (*ModelStatusResult) ProtoMessage()

+ func (m *ModelStatusResult) GetFailed() int32

+ func (m *ModelStatusResult) GetFailedModels() []*ModelError

+ func (m *ModelStatusResult) GetMessage() string

+ func (m *ModelStatusResult) GetSucceeded() int32

+ func (m *ModelStatusResult) Reset()

+ func (m *ModelStatusResult) String() string

+ func (m *ModelStatusResult) XXX_DiscardUnknown()

+ func (m *ModelStatusResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *ModelStatusResult) XXX_Merge(src proto.Message)

+ func (m *ModelStatusResult) XXX_Size() int

+ func (m *ModelStatusResult) XXX_Unmarshal(b []byte) error

+ type Models struct

+ DetailedResponse bool

+ Models []*Model

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*Models) Descriptor() ([]byte, []int)

+ func (*Models) ProtoMessage()

+ func (m *Models) GetDetailedResponse() bool

+ func (m *Models) GetModels() []*Model

+ func (m *Models) Reset()

+ func (m *Models) String() string

+ func (m *Models) XXX_DiscardUnknown()

+ func (m *Models) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Models) XXX_Merge(src proto.Message)

+ func (m *Models) XXX_Size() int

+ func (m *Models) XXX_Unmarshal(b []byte) error

+ type StatusResult struct

+ Failed int32

+ FailedCompactMetrics []*CompactMetricError

+ FailedMetrics []*MetricError

+ FailedTaggedMetrics []*TaggedMetricError

+ Message string

+ Succeeded int32

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*StatusResult) Descriptor() ([]byte, []int)

+ func (*StatusResult) ProtoMessage()

+ func (m *StatusResult) GetFailed() int32

+ func (m *StatusResult) GetFailedCompactMetrics() []*CompactMetricError

+ func (m *StatusResult) GetFailedMetrics() []*MetricError

+ func (m *StatusResult) GetFailedTaggedMetrics() []*TaggedMetricError

+ func (m *StatusResult) GetMessage() string

+ func (m *StatusResult) GetSucceeded() int32

+ func (m *StatusResult) Reset()

+ func (m *StatusResult) String() string

+ func (m *StatusResult) XXX_DiscardUnknown()

+ func (m *StatusResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *StatusResult) XXX_Merge(src proto.Message)

+ func (m *StatusResult) XXX_Size() int

+ func (m *StatusResult) XXX_Unmarshal(b []byte) error

+ type TaggedMetric struct

+ Metric string

+ Tags map[string]string

+ Timestamp int64

+ Value float64

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*TaggedMetric) Descriptor() ([]byte, []int)

+ func (*TaggedMetric) ProtoMessage()

+ func (m *TaggedMetric) GetMetric() string

+ func (m *TaggedMetric) GetTags() map[string]string

+ func (m *TaggedMetric) GetTimestamp() int64

+ func (m *TaggedMetric) GetValue() float64

+ func (m *TaggedMetric) Reset()

+ func (m *TaggedMetric) String() string

+ func (m *TaggedMetric) XXX_DiscardUnknown()

+ func (m *TaggedMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *TaggedMetric) XXX_Merge(src proto.Message)

+ func (m *TaggedMetric) XXX_Size() int

+ func (m *TaggedMetric) XXX_Unmarshal(b []byte) error

+ type TaggedMetricError struct

+ Error string

+ Metric *TaggedMetric

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*TaggedMetricError) Descriptor() ([]byte, []int)

+ func (*TaggedMetricError) ProtoMessage()

+ func (m *TaggedMetricError) GetError() string

+ func (m *TaggedMetricError) GetMetric() *TaggedMetric

+ func (m *TaggedMetricError) Reset()

+ func (m *TaggedMetricError) String() string

+ func (m *TaggedMetricError) XXX_DiscardUnknown()

+ func (m *TaggedMetricError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *TaggedMetricError) XXX_Merge(src proto.Message)

+ func (m *TaggedMetricError) XXX_Size() int

+ func (m *TaggedMetricError) XXX_Unmarshal(b []byte) error

+ type UnimplementedDataReceiverServiceServer struct

+ func (*UnimplementedDataReceiverServiceServer) PutMetric(srv DataReceiverService_PutMetricServer) error

+ func (*UnimplementedDataReceiverServiceServer) PutMetrics(ctx context.Context, req *Metrics) (*StatusResult, error)

+ func (*UnimplementedDataReceiverServiceServer) PutModels(ctx context.Context, req *Models) (*ModelStatusResult, error)

+ type Void struct

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*Void) Descriptor() ([]byte, []int)

+ func (*Void) ProtoMessage()

+ func (m *Void) Reset()

+ func (m *Void) String() string

+ func (m *Void) XXX_DiscardUnknown()

+ func (m *Void) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Void) XXX_Merge(src proto.Message)

+ func (m *Void) XXX_Size() int

+ func (m *Void) XXX_Unmarshal(b []byte) error

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL