datasource

type CacheDataSource struct {
	// contains filtered or unexported fields
}

type CacheLoggerDataSourceInterface interface {
	DataSource
	CacheLoggerInterface
}

type CacheLoggerInterface interface {
	LogCache(connection, typeParam, action string, key string, value string, duration float32, expiration float32)
	LogCacheMiss(connection, action string, key string, value string, misses int, duration float32, expiration float32)
}

type CommandLoggerDataSourceInterface interface {
	DataSource
	CommandLoggerInterface
}

type CommandLoggerInterface interface {
	LogCommand(command string, key string, duration float32)
}

type DataBuffer struct {
	Log                  []interface{}            `json:"log"`
	DatabaseQueries      []interface{}            `json:"databaseQueries"`
	DatabaseQueriesCount int                      `json:"databaseQueriesCount"`
	DatabaseDuration     float32                  `json:"databaseDuration"`
	RedisCommands        []interface{}            `json:"redisCommands"`
	CacheQueries         []interface{}            `json:"cacheQueries"`
	CacheTime            float32                  `json:"cacheTime"`
	CacheDeletes         int16                    `json:"cacheDeletes"`
	CacheWrites          int16                    `json:"cacheWrites"`
	CacheReads           int16                    `json:"cacheReads"`
	CacheHits            int16                    `json:"cacheHits"`
	TimelineData         map[string]interface{}   `json:"timelineData"`
	Time                 float64                  `json:"time"`
	Controller           string                   `json:"controller"`
	Middleware           []string                 `json:"middleware"`
	MemoryUsage          uint64                   `json:"memoryUsage"`
	ResponseTime         float64                  `json:"responseTime"`
	ResponseDuration     float64                  `json:"responseDuration"`
	ResponseStatus       int16                    `json:"responseStatus"`
	UserData             []map[string]interface{} `json:"userData"`
}

type DataSource interface {
	Resolve(dataBuffer *DataBuffer)
}

type DatabaseDataSource struct {
	// contains filtered or unexported fields
}

type LoggerDataSource struct {
	// contains filtered or unexported fields
}

type LoggerDataSourceInterface interface {
	DataSource
	LoggerInterface
}

type LoggerInterface interface {
	LogDebugSlice(name string, debugData []string)
	LogDebugMap(name string, debugData map[string]string)
	LogDebugString(name string, debugData string)
}

type QueryLoggerDataSourceInterface interface {
	DataSource
	QueryLoggerInterface
}

type QueryLoggerInterface interface {
	LogQuery(model, query string, duration float32, bind []interface{})
}

type RedisDataSource struct {
	// contains filtered or unexported fields
}

type RequestLoggerDataSourceInterface interface {
	DataSource
	RequestLoggerInterface
}

type RequestLoggerInterface interface {
	SetStartTime(start time.Time)
	SetResponseTime(responseTime time.Time)
	SetResponseStatus(status int16)
	StartMemoryUsage()
	EndMemoryUsage()
	SetController(controller string, method string)
	SetMiddleware([]string)
}

type RequestResponseDataSource struct {
	// contains filtered or unexported fields
}

type TimelineDataSource struct {
	// contains filtered or unexported fields
}

type TimelineLoggerDataSourceInterface interface {
	DataSource
	TimelineLoggerInterface
}

type TimelineLoggerInterface interface {
	StartEvent(event string, description string)
	EndEvent(event string)
}

type UserDataDataSource struct {
	Title  string                   `json:"title"`
	Data   []map[string]interface{} `json:"data"`
	ShowAs string                   `json:"showAs"` // Present data as "counters" or "table"
	// contains filtered or unexported fields
}

type UserDataInterface interface {
	SetTitle(title string)
	SetShowAs(showAs string)
	LogTable(data map[string]interface{}, title string, labels map[string]string)
}

type UserDataSourceInterface interface {
	DataSource
	UserDataInterface
}