Add opt-in anonymous stats reporting (#2249)

* Initial phone home stats queries

* Add userAgent to UpdateDeviceLastSeen
Add new Table for tracking daily user vists

* Add user_daily_visits table

* Fix queries

* userapi stats tables & queries

* userapi interface and internal api

* sycnapi stats queries

* testing phone home stats

* Add complete config to syncapi

* add missing files

* Fix queries

* Send empty request

* Add version & monolith stats

* Add configuration for phone home stats

* Move WASM to its own file, add config and comments

* Add tracing methods

* Add total rooms

* Add more fields, actually send data somewhere

* Move stats to the userapi

* Move phone home stats to util package

* Cleanup

* Linter & parts of GH comments

* More GH comments changes
- Move comments to SQL statements
- Shrink interface, add struct for stats
- No fatal errors, use defaults

* Be more explicit when querying

* Fix wrong calculation & wrong query params
Add tests

* Add Windows stats

* ADd build constraint

* Use new testing structure
Fix issues with getting values when using SQLite
Fix wrong AddDate value
Export UpdateUserDailyVisits

* Fix query params

* Fix test

* Add comment about countR30UsersSQL and countR30UsersV2SQL; fix test

* Update config

* Also update example config file

* Use OS level proxy, update logging

Co-authored-by: kegsay <kegan@matrix.org>
This commit is contained in:
Till 2022-05-04 19:04:28 +02:00 committed by GitHub
parent b0a9e85c4a
commit 3c940c428d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
24 changed files with 1582 additions and 14 deletions

View file

@ -18,9 +18,11 @@ import (
"context"
"database/sql"
"encoding/json"
"time"
"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
"github.com/matrix-org/dendrite/userapi/api"
"github.com/matrix-org/dendrite/userapi/types"
)
type AccountDataTable interface {
@ -48,7 +50,7 @@ type DevicesTable interface {
SelectDeviceByID(ctx context.Context, localpart, deviceID string) (*api.Device, error)
SelectDevicesByLocalpart(ctx context.Context, txn *sql.Tx, localpart, exceptDeviceID string) ([]api.Device, error)
SelectDevicesByID(ctx context.Context, deviceIDs []string) ([]api.Device, error)
UpdateDeviceLastSeen(ctx context.Context, txn *sql.Tx, localpart, deviceID, ipAddr string) error
UpdateDeviceLastSeen(ctx context.Context, txn *sql.Tx, localpart, deviceID, ipAddr, userAgent string) error
}
type KeyBackupTable interface {
@ -111,6 +113,11 @@ type NotificationTable interface {
SelectRoomCounts(ctx context.Context, txn *sql.Tx, localpart, roomID string) (total int64, highlight int64, _ error)
}
type StatsTable interface {
UserStatistics(ctx context.Context, txn *sql.Tx) (*types.UserStatistics, *types.DatabaseEngine, error)
UpdateUserDailyVisits(ctx context.Context, txn *sql.Tx, startTime, lastUpdate time.Time) error
}
type NotificationFilter uint32
const (

View file

@ -0,0 +1,319 @@
package tables_test
import (
"context"
"database/sql"
"fmt"
"reflect"
"testing"
"time"
"github.com/matrix-org/dendrite/internal/sqlutil"
"github.com/matrix-org/dendrite/setup/config"
"github.com/matrix-org/dendrite/test"
"github.com/matrix-org/dendrite/userapi/api"
"github.com/matrix-org/dendrite/userapi/storage/postgres"
"github.com/matrix-org/dendrite/userapi/storage/sqlite3"
"github.com/matrix-org/dendrite/userapi/storage/tables"
"github.com/matrix-org/dendrite/userapi/types"
"github.com/matrix-org/gomatrixserverlib"
"github.com/matrix-org/util"
)
func mustMakeDBs(t *testing.T, dbType test.DBType) (
*sql.DB, tables.AccountsTable, tables.DevicesTable, tables.StatsTable, func(),
) {
t.Helper()
var (
accTable tables.AccountsTable
devTable tables.DevicesTable
statsTable tables.StatsTable
err error
)
connStr, close := test.PrepareDBConnectionString(t, dbType)
db, err := sqlutil.Open(&config.DatabaseOptions{
ConnectionString: config.DataSource(connStr),
}, nil)
if err != nil {
t.Fatalf("failed to open db: %s", err)
}
switch dbType {
case test.DBTypeSQLite:
accTable, err = sqlite3.NewSQLiteAccountsTable(db, "localhost")
if err != nil {
t.Fatalf("unable to create acc db: %v", err)
}
devTable, err = sqlite3.NewSQLiteDevicesTable(db, "localhost")
if err != nil {
t.Fatalf("unable to open device db: %v", err)
}
statsTable, err = sqlite3.NewSQLiteStatsTable(db, "localhost")
if err != nil {
t.Fatalf("unable to open stats db: %v", err)
}
case test.DBTypePostgres:
accTable, err = postgres.NewPostgresAccountsTable(db, "localhost")
if err != nil {
t.Fatalf("unable to create acc db: %v", err)
}
devTable, err = postgres.NewPostgresDevicesTable(db, "localhost")
if err != nil {
t.Fatalf("unable to open device db: %v", err)
}
statsTable, err = postgres.NewPostgresStatsTable(db, "localhost")
if err != nil {
t.Fatalf("unable to open stats db: %v", err)
}
}
return db, accTable, devTable, statsTable, close
}
func mustMakeAccountAndDevice(
t *testing.T,
ctx context.Context,
accDB tables.AccountsTable,
devDB tables.DevicesTable,
localpart string,
accType api.AccountType,
userAgent string,
) {
t.Helper()
appServiceID := ""
if accType == api.AccountTypeAppService {
appServiceID = util.RandomString(16)
}
_, err := accDB.InsertAccount(ctx, nil, localpart, "", appServiceID, accType)
if err != nil {
t.Fatalf("unable to create account: %v", err)
}
_, err = devDB.InsertDevice(ctx, nil, "deviceID", localpart, util.RandomString(16), nil, "", userAgent)
if err != nil {
t.Fatalf("unable to create device: %v", err)
}
}
func mustUpdateDeviceLastSeen(
t *testing.T,
ctx context.Context,
db *sql.DB,
localpart string,
timestamp time.Time,
) {
t.Helper()
_, err := db.ExecContext(ctx, "UPDATE device_devices SET last_seen_ts = $1 WHERE localpart = $2", gomatrixserverlib.AsTimestamp(timestamp), localpart)
if err != nil {
t.Fatalf("unable to update device last seen")
}
}
func mustUserUpdateRegistered(
t *testing.T,
ctx context.Context,
db *sql.DB,
localpart string,
timestamp time.Time,
) {
_, err := db.ExecContext(ctx, "UPDATE account_accounts SET created_ts = $1 WHERE localpart = $2", gomatrixserverlib.AsTimestamp(timestamp), localpart)
if err != nil {
t.Fatalf("unable to update device last seen")
}
}
// These tests must run sequentially, as they build up on each other
func Test_UserStatistics(t *testing.T) {
ctx := context.Background()
test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {
db, accDB, devDB, statsDB, close := mustMakeDBs(t, dbType)
defer close()
wantType := "SQLite"
if dbType == test.DBTypePostgres {
wantType = "Postgres"
}
t.Run(fmt.Sprintf("want %s database engine", wantType), func(t *testing.T) {
_, gotDB, err := statsDB.UserStatistics(ctx, nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if wantType != gotDB.Engine { // can't use DeepEqual, as the Version might differ
t.Errorf("UserStatistics() got DB engine = %+v, want %s", gotDB.Engine, wantType)
}
})
t.Run("Want Users", func(t *testing.T) {
mustMakeAccountAndDevice(t, ctx, accDB, devDB, "user1", api.AccountTypeUser, "Element Android")
mustMakeAccountAndDevice(t, ctx, accDB, devDB, "user2", api.AccountTypeUser, "Element iOS")
mustMakeAccountAndDevice(t, ctx, accDB, devDB, "user3", api.AccountTypeUser, "Element web")
mustMakeAccountAndDevice(t, ctx, accDB, devDB, "user4", api.AccountTypeGuest, "Element Electron")
mustMakeAccountAndDevice(t, ctx, accDB, devDB, "user5", api.AccountTypeAdmin, "gecko")
mustMakeAccountAndDevice(t, ctx, accDB, devDB, "user6", api.AccountTypeAppService, "gecko")
gotStats, _, err := statsDB.UserStatistics(ctx, nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
wantStats := &types.UserStatistics{
RegisteredUsersByType: map[string]int64{
"native": 4,
"guest": 1,
"bridged": 1,
},
R30Users: map[string]int64{},
R30UsersV2: map[string]int64{
"ios": 0,
"android": 0,
"web": 0,
"electron": 0,
"all": 0,
},
AllUsers: 6,
NonBridgedUsers: 5,
DailyUsers: 6,
MonthlyUsers: 6,
}
if !reflect.DeepEqual(gotStats, wantStats) {
t.Errorf("UserStatistics() gotStats = \n%+v\nwant\n%+v", gotStats, wantStats)
}
})
t.Run("Users not active for one/two month", func(t *testing.T) {
mustUpdateDeviceLastSeen(t, ctx, db, "user1", time.Now().AddDate(0, -2, 0))
mustUpdateDeviceLastSeen(t, ctx, db, "user2", time.Now().AddDate(0, -1, 0))
gotStats, _, err := statsDB.UserStatistics(ctx, nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
wantStats := &types.UserStatistics{
RegisteredUsersByType: map[string]int64{
"native": 4,
"guest": 1,
"bridged": 1,
},
R30Users: map[string]int64{},
R30UsersV2: map[string]int64{
"ios": 0,
"android": 0,
"web": 0,
"electron": 0,
"all": 0,
},
AllUsers: 6,
NonBridgedUsers: 5,
DailyUsers: 4,
MonthlyUsers: 4,
}
if !reflect.DeepEqual(gotStats, wantStats) {
t.Errorf("UserStatistics() gotStats = \n%+v\nwant\n%+v", gotStats, wantStats)
}
})
/* R30Users counts the number of 30 day retained users, defined as:
- Users who have created their accounts more than 30 days ago
- Where last seen at most 30 days ago
- Where account creation and last_seen are > 30 days apart
*/
t.Run("R30Users tests", func(t *testing.T) {
mustUserUpdateRegistered(t, ctx, db, "user1", time.Now().AddDate(0, -2, 0))
mustUpdateDeviceLastSeen(t, ctx, db, "user1", time.Now())
mustUserUpdateRegistered(t, ctx, db, "user4", time.Now().AddDate(0, -2, 0))
mustUpdateDeviceLastSeen(t, ctx, db, "user4", time.Now())
startTime := time.Now().AddDate(0, 0, -2)
err := statsDB.UpdateUserDailyVisits(ctx, nil, startTime, startTime.Truncate(time.Hour*24).Add(time.Hour))
if err != nil {
t.Fatalf("unable to update daily visits stats: %v", err)
}
gotStats, _, err := statsDB.UserStatistics(ctx, nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
wantStats := &types.UserStatistics{
RegisteredUsersByType: map[string]int64{
"native": 3,
"bridged": 1,
},
R30Users: map[string]int64{
"all": 2,
"android": 1,
"electron": 1,
},
R30UsersV2: map[string]int64{
"ios": 0,
"android": 0,
"web": 0,
"electron": 0,
"all": 0,
},
AllUsers: 6,
NonBridgedUsers: 5,
DailyUsers: 5,
MonthlyUsers: 5,
}
if !reflect.DeepEqual(gotStats, wantStats) {
t.Errorf("UserStatistics() gotStats = \n%+v\nwant\n%+v", gotStats, wantStats)
}
})
/*
R30UsersV2 counts the number of 30 day retained users, defined as users that:
- Appear more than once in the past 60 days
- Have more than 30 days between the most and least recent appearances that occurred in the past 60 days.
most recent -> neueste
least recent -> älteste
*/
t.Run("R30UsersV2 tests", func(t *testing.T) {
// generate some data
for i := 100; i > 0; i-- {
mustUpdateDeviceLastSeen(t, ctx, db, "user1", time.Now().AddDate(0, 0, -i))
mustUpdateDeviceLastSeen(t, ctx, db, "user5", time.Now().AddDate(0, 0, -i))
startTime := time.Now().AddDate(0, 0, -i)
err := statsDB.UpdateUserDailyVisits(ctx, nil, startTime, startTime.Truncate(time.Hour*24).Add(time.Hour))
if err != nil {
t.Fatalf("unable to update daily visits stats: %v", err)
}
}
gotStats, _, err := statsDB.UserStatistics(ctx, nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
wantStats := &types.UserStatistics{
RegisteredUsersByType: map[string]int64{
"native": 3,
"bridged": 1,
},
R30Users: map[string]int64{
"all": 2,
"android": 1,
"electron": 1,
},
R30UsersV2: map[string]int64{
"ios": 0,
"android": 1,
"web": 1,
"electron": 0,
"all": 2,
},
AllUsers: 6,
NonBridgedUsers: 5,
DailyUsers: 3,
MonthlyUsers: 5,
}
if !reflect.DeepEqual(gotStats, wantStats) {
t.Errorf("UserStatistics() gotStats = \n%+v\nwant\n%+v", gotStats, wantStats)
}
})
})
}