status-go/appmetrics/database.go

316 lines
7.0 KiB
Go

package appmetrics
import (
"database/sql"
"encoding/json"
"errors"
"strings"
"time"
"github.com/xeipuuv/gojsonschema"
)
type AppMetricEventType string
// Value is `json.RawMessage` so we can send any json shape, including strings
// Validation is handled using JSON schemas defined in validators.go, instead of Golang structs
type AppMetric struct {
ID int `json:"-"`
MessageID string `json:"message_id"`
Event AppMetricEventType `json:"event"`
Value json.RawMessage `json:"value"`
AppVersion string `json:"app_version"`
OS string `json:"os"`
SessionID string `json:"session_id"`
CreatedAt time.Time `json:"created_at"`
Processed bool `json:"processed"`
ReceivedAt time.Time `json:"received_at"`
}
type AppMetricValidationError struct {
Metric AppMetric
Errors []gojsonschema.ResultError
}
type Page struct {
AppMetrics []AppMetric
TotalCount int
}
const (
// status-react navigation events
NavigateTo AppMetricEventType = "navigate-to"
ScreensOnWillFocus AppMetricEventType = "screens/on-will-focus"
)
// EventSchemaMap Every event should have a schema attached
var EventSchemaMap = map[AppMetricEventType]interface{}{
NavigateTo: NavigateToCofxSchema,
ScreensOnWillFocus: NavigateToCofxSchema,
}
func NewDB(db *sql.DB) *Database {
return &Database{db: db}
}
// Database sql wrapper for operations with browser objects.
type Database struct {
db *sql.DB
}
// Close closes database.
func (db Database) Close() error {
return db.db.Close()
}
func jsonschemaErrorsToError(validationErrors []AppMetricValidationError) error {
var fieldErrors []string
for _, appMetricValidationError := range validationErrors {
metric := appMetricValidationError.Metric
errors := appMetricValidationError.Errors
var errorDesc string = "Error in event: " + string(metric.Event) + " - "
for _, e := range errors {
errorDesc = errorDesc + "value." + e.Context().String() + ":" + e.Description()
}
fieldErrors = append(fieldErrors, errorDesc)
}
return errors.New(strings.Join(fieldErrors[:], "/ "))
}
func (db *Database) ValidateAppMetrics(appMetrics []AppMetric) (err error) {
var calculatedErrors []AppMetricValidationError
for _, metric := range appMetrics {
schema := EventSchemaMap[metric.Event]
if schema == nil {
return errors.New("No schema defined for: " + string(metric.Event))
}
schemaLoader := gojsonschema.NewGoLoader(schema)
valLoader := gojsonschema.NewStringLoader(string(metric.Value))
res, err := gojsonschema.Validate(schemaLoader, valLoader)
if err != nil {
return err
}
// validate all metrics and save errors
if !res.Valid() {
calculatedErrors = append(calculatedErrors, AppMetricValidationError{metric, res.Errors()})
}
}
if len(calculatedErrors) > 0 {
return jsonschemaErrorsToError(calculatedErrors)
}
return
}
func (db *Database) SaveAppMetrics(appMetrics []AppMetric, sessionID string) (err error) {
var (
tx *sql.Tx
insert *sql.Stmt
)
// make sure that the shape of the metric is same as expected
err = db.ValidateAppMetrics(appMetrics)
if err != nil {
return err
}
// start txn
tx, err = db.db.Begin()
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
insert, err = tx.Prepare("INSERT INTO app_metrics (event, value, app_version, operating_system, session_id, processed) VALUES (?, ?, ?, ?, ?, ?)")
if err != nil {
return err
}
for _, metric := range appMetrics {
_, err = insert.Exec(metric.Event, metric.Value, metric.AppVersion, metric.OS, sessionID, metric.Processed)
if err != nil {
return
}
}
return
}
func (db *Database) GetAppMetrics(limit int, offset int) (page Page, err error) {
countErr := db.db.QueryRow("SELECT count(*) FROM app_metrics").Scan(&page.TotalCount)
if countErr != nil {
return page, countErr
}
rows, err := db.db.Query("SELECT id, event, value, app_version, operating_system, session_id, created_at, processed FROM app_metrics LIMIT ? OFFSET ?", limit, offset)
if err != nil {
return page, err
}
defer rows.Close()
page.AppMetrics, err = db.getFromRows(rows)
return page, err
}
func (db *Database) getFromRows(rows *sql.Rows) (appMetrics []AppMetric, err error) {
var metrics []AppMetric
for rows.Next() {
metric := AppMetric{}
err = rows.Scan(
&metric.ID,
&metric.Event,
&metric.Value,
&metric.AppVersion,
&metric.OS,
&metric.SessionID,
&metric.CreatedAt,
&metric.Processed,
)
if err != nil {
return metrics, err
}
metrics = append(metrics, metric)
}
return metrics, nil
}
func (db *Database) GetUnprocessed() ([]AppMetric, error) {
rows, err := db.db.Query("SELECT id, event, value, app_version, operating_system, session_id, created_at, processed FROM app_metrics WHERE processed IS ? ORDER BY session_id ASC, created_at ASC", false)
if err != nil {
return nil, err
}
defer rows.Close()
return db.getFromRows(rows)
}
func (db *Database) GetUnprocessedGroupedBySession() (map[string][]AppMetric, error) {
uam, err := db.GetUnprocessed()
if err != nil {
return nil, err
}
out := map[string][]AppMetric{}
for _, am := range uam {
out[am.SessionID] = append(out[am.SessionID], am)
}
return out, nil
}
func (db *Database) SetToProcessedByIDs(ids []int) (err error) {
var (
tx *sql.Tx
update *sql.Stmt
)
// start txn
tx, err = db.db.Begin()
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
// Generate prepared statement IN list
in := "("
for i := 0; i < len(ids); i++ {
in += "?,"
}
in = in[:len(in)-1] + ")"
update, err = tx.Prepare("UPDATE app_metrics SET processed = 1 WHERE id IN " + in)
if err != nil {
return err
}
// Convert the ids into Stmt.Exec compatible variadic
args := make([]interface{}, 0, len(ids))
for _, id := range ids {
args = append(args, id)
}
_, err = update.Exec(args...)
if err != nil {
return
}
return
}
func (db *Database) SetToProcessed(appMetrics []AppMetric) (err error) {
ids := GetAppMetricsIDs(appMetrics)
return db.SetToProcessedByIDs(ids)
}
func (db *Database) GetMessagesOlderThan(date *time.Time) ([]AppMetric, error) {
rows, err := db.db.Query("SELECT id, event, value, app_version, operating_system, session_id, created_at, processed FROM app_metrics WHERE created_at < ?", date)
if err != nil {
return nil, err
}
defer rows.Close()
return db.getFromRows(rows)
}
func (db *Database) DeleteOlderThan(date *time.Time) (err error) {
var (
tx *sql.Tx
d *sql.Stmt
)
// start txn
tx, err = db.db.Begin()
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
d, err = tx.Prepare("DELETE FROM app_metrics WHERE created_at < ?")
if err != nil {
return err
}
_, err = d.Exec(date)
if err != nil {
return
}
return
}
func GetAppMetricsIDs(appMetrics []AppMetric) []int {
var ids []int
for _, am := range appMetrics {
ids = append(ids, am.ID)
}
return ids
}