Merge branch 'develop'

15 files changed, 882 insertions, 0 deletions

diff --git a/src/services/chart/charts/classes/active-users.ts b/src/services/chart/charts/classes/active-users.ts
new file mode 100644
index 0000000000..5128150de6
--- /dev/null
+++ b/src/services/chart/charts/classes/active-users.ts
@@ -0,0 +1,35 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { User } from '../../../../models/entities/user';
+import { SchemaType } from '../../../../misc/schema';
+import { Users } from '../../../../models';
+import { name, schema } from '../schemas/active-users';
+
+type ActiveUsersLog = SchemaType<typeof schema>;
+
+export default class ActiveUsersChart extends Chart<ActiveUsersLog> {
+	constructor() {
+		super(name, schema);
+	}
+
+	@autobind
+	protected genNewLog(latest: ActiveUsersLog): DeepPartial<ActiveUsersLog> {
+		return {};
+	}
+
+	@autobind
+	protected async fetchActual(): Promise<DeepPartial<ActiveUsersLog>> {
+		return {};
+	}
+
+	@autobind
+	public async update(user: User) {
+		const update: Obj = {
+			count: 1
+		};
+
+		await this.incIfUnique({
+			[Users.isLocalUser(user) ? 'local' : 'remote']: update
+		}, 'users', user.id);
+	}
+}
diff --git a/src/services/chart/charts/classes/drive.ts b/src/services/chart/charts/classes/drive.ts
new file mode 100644
index 0000000000..ae52df19ac
--- /dev/null
+++ b/src/services/chart/charts/classes/drive.ts
@@ -0,0 +1,69 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { DriveFiles } from '../../../../models';
+import { Not } from 'typeorm';
+import { DriveFile } from '../../../../models/entities/drive-file';
+import { name, schema } from '../schemas/drive';
+
+type DriveLog = SchemaType<typeof schema>;
+
+export default class DriveChart extends Chart<DriveLog> {
+	constructor() {
+		super(name, schema);
+	}
+
+	@autobind
+	protected genNewLog(latest: DriveLog): DeepPartial<DriveLog> {
+		return {
+			local: {
+				totalCount: latest.local.totalCount,
+				totalSize: latest.local.totalSize,
+			},
+			remote: {
+				totalCount: latest.remote.totalCount,
+				totalSize: latest.remote.totalSize,
+			}
+		};
+	}
+
+	@autobind
+	protected async fetchActual(): Promise<DeepPartial<DriveLog>> {
+		const [localCount, remoteCount, localSize, remoteSize] = await Promise.all([
+			DriveFiles.count({ userHost: null }),
+			DriveFiles.count({ userHost: Not(null) }),
+			DriveFiles.clacDriveUsageOfLocal(),
+			DriveFiles.clacDriveUsageOfRemote()
+		]);
+
+		return {
+			local: {
+				totalCount: localCount,
+				totalSize: localSize,
+			},
+			remote: {
+				totalCount: remoteCount,
+				totalSize: remoteSize,
+			}
+		};
+	}
+
+	@autobind
+	public async update(file: DriveFile, isAdditional: boolean) {
+		const update: Obj = {};
+
+		update.totalCount = isAdditional ? 1 : -1;
+		update.totalSize = isAdditional ? file.size : -file.size;
+		if (isAdditional) {
+			update.incCount = 1;
+			update.incSize = file.size;
+		} else {
+			update.decCount = 1;
+			update.decSize = file.size;
+		}
+
+		await this.inc({
+			[file.userHost === null ? 'local' : 'remote']: update
+		});
+	}
+}
diff --git a/src/services/chart/charts/classes/federation.ts b/src/services/chart/charts/classes/federation.ts
new file mode 100644
index 0000000000..bd2c497e7b
--- /dev/null
+++ b/src/services/chart/charts/classes/federation.ts
@@ -0,0 +1,51 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { Instances } from '../../../../models';
+import { name, schema } from '../schemas/federation';
+
+type FederationLog = SchemaType<typeof schema>;
+
+export default class FederationChart extends Chart<FederationLog> {
+	constructor() {
+		super(name, schema);
+	}
+
+	@autobind
+	protected genNewLog(latest: FederationLog): DeepPartial<FederationLog> {
+		return {
+			instance: {
+				total: latest.instance.total,
+			}
+		};
+	}
+
+	@autobind
+	protected async fetchActual(): Promise<DeepPartial<FederationLog>> {
+		const [total] = await Promise.all([
+			Instances.count({})
+		]);
+
+		return {
+			instance: {
+				total: total,
+			}
+		};
+	}
+
+	@autobind
+	public async update(isAdditional: boolean) {
+		const update: Obj = {};
+
+		update.total = isAdditional ? 1 : -1;
+		if (isAdditional) {
+			update.inc = 1;
+		} else {
+			update.dec = 1;
+		}
+
+		await this.inc({
+			instance: update
+		});
+	}
+}
diff --git a/src/services/chart/charts/classes/hashtag.ts b/src/services/chart/charts/classes/hashtag.ts
new file mode 100644
index 0000000000..38c3a94f0c
--- /dev/null
+++ b/src/services/chart/charts/classes/hashtag.ts
@@ -0,0 +1,35 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { User } from '../../../../models/entities/user';
+import { SchemaType } from '../../../../misc/schema';
+import { Users } from '../../../../models';
+import { name, schema } from '../schemas/hashtag';
+
+type HashtagLog = SchemaType<typeof schema>;
+
+export default class HashtagChart extends Chart<HashtagLog> {
+	constructor() {
+		super(name, schema, true);
+	}
+
+	@autobind
+	protected genNewLog(latest: HashtagLog): DeepPartial<HashtagLog> {
+		return {};
+	}
+
+	@autobind
+	protected async fetchActual(): Promise<DeepPartial<HashtagLog>> {
+		return {};
+	}
+
+	@autobind
+	public async update(hashtag: string, user: User) {
+		const update: Obj = {
+			count: 1
+		};
+
+		await this.incIfUnique({
+			[Users.isLocalUser(user) ? 'local' : 'remote']: update
+		}, 'users', user.id, hashtag);
+	}
+}
diff --git a/src/services/chart/charts/classes/instance.ts b/src/services/chart/charts/classes/instance.ts
new file mode 100644
index 0000000000..f3d341f383
--- /dev/null
+++ b/src/services/chart/charts/classes/instance.ts
@@ -0,0 +1,173 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { DriveFiles, Followings, Users, Notes } from '../../../../models';
+import { DriveFile } from '../../../../models/entities/drive-file';
+import { name, schema } from '../schemas/instance';
+import { Note } from '../../../../models/entities/note';
+import { toPuny } from '../../../../misc/convert-host';
+
+type InstanceLog = SchemaType<typeof schema>;
+
+export default class InstanceChart extends Chart<InstanceLog> {
+	constructor() {
+		super(name, schema);
+	}
+
+	@autobind
+	protected genNewLog(latest: InstanceLog): DeepPartial<InstanceLog> {
+		return {
+			notes: {
+				total: latest.notes.total,
+			},
+			users: {
+				total: latest.users.total,
+			},
+			following: {
+				total: latest.following.total,
+			},
+			followers: {
+				total: latest.followers.total,
+			},
+			drive: {
+				totalFiles: latest.drive.totalFiles,
+				totalUsage: latest.drive.totalUsage,
+			}
+		};
+	}
+
+	@autobind
+	protected async fetchActual(group: string): Promise<DeepPartial<InstanceLog>> {
+		const [
+			notesCount,
+			usersCount,
+			followingCount,
+			followersCount,
+			driveFiles,
+			driveUsage,
+		] = await Promise.all([
+			Notes.count({ userHost: group }),
+			Users.count({ host: group }),
+			Followings.count({ followerHost: group }),
+			Followings.count({ followeeHost: group }),
+			DriveFiles.count({ userHost: group }),
+			DriveFiles.clacDriveUsageOfHost(group),
+		]);
+
+		return {
+			notes: {
+				total: notesCount,
+			},
+			users: {
+				total: usersCount,
+			},
+			following: {
+				total: followingCount,
+			},
+			followers: {
+				total: followersCount,
+			},
+			drive: {
+				totalFiles: driveFiles,
+				totalUsage: driveUsage,
+			}
+		};
+	}
+
+	@autobind
+	public async requestReceived(host: string) {
+		await this.inc({
+			requests: {
+				received: 1
+			}
+		}, toPuny(host));
+	}
+
+	@autobind
+	public async requestSent(host: string, isSucceeded: boolean) {
+		const update: Obj = {};
+
+		if (isSucceeded) {
+			update.succeeded = 1;
+		} else {
+			update.failed = 1;
+		}
+
+		await this.inc({
+			requests: update
+		}, toPuny(host));
+	}
+
+	@autobind
+	public async newUser(host: string) {
+		await this.inc({
+			users: {
+				total: 1,
+				inc: 1
+			}
+		}, toPuny(host));
+	}
+
+	@autobind
+	public async updateNote(host: string, note: Note, isAdditional: boolean) {
+		const diffs = {} as any;
+
+		if (note.replyId != null) {
+			diffs.reply = isAdditional ? 1 : -1;
+		} else if (note.renoteId != null) {
+			diffs.renote = isAdditional ? 1 : -1;
+		} else {
+			diffs.normal = isAdditional ? 1 : -1;
+		}
+
+		await this.inc({
+			notes: {
+				total: isAdditional ? 1 : -1,
+				inc: isAdditional ? 1 : 0,
+				dec: isAdditional ? 0 : 1,
+				diffs: diffs
+			}
+		}, toPuny(host));
+	}
+
+	@autobind
+	public async updateFollowing(host: string, isAdditional: boolean) {
+		await this.inc({
+			following: {
+				total: isAdditional ? 1 : -1,
+				inc: isAdditional ? 1 : 0,
+				dec: isAdditional ? 0 : 1,
+			}
+		}, toPuny(host));
+	}
+
+	@autobind
+	public async updateFollowers(host: string, isAdditional: boolean) {
+		await this.inc({
+			followers: {
+				total: isAdditional ? 1 : -1,
+				inc: isAdditional ? 1 : 0,
+				dec: isAdditional ? 0 : 1,
+			}
+		}, toPuny(host));
+	}
+
+	@autobind
+	public async updateDrive(file: DriveFile, isAdditional: boolean) {
+		const update: Obj = {};
+
+		update.totalFiles = isAdditional ? 1 : -1;
+		update.totalUsage = isAdditional ? file.size : -file.size;
+		if (isAdditional) {
+			update.incFiles = 1;
+			update.incUsage = file.size;
+		} else {
+			update.decFiles = 1;
+			update.decUsage = file.size;
+		}
+
+		await this.inc({
+			drive: update
+		}, file.userHost);
+	}
+}
diff --git a/src/services/chart/charts/classes/network.ts b/src/services/chart/charts/classes/network.ts
new file mode 100644
index 0000000000..8b26e5c4c2
--- /dev/null
+++ b/src/services/chart/charts/classes/network.ts
@@ -0,0 +1,34 @@
+import autobind from 'autobind-decorator';
+import Chart, { DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { name, schema } from '../schemas/network';
+
+type NetworkLog = SchemaType<typeof schema>;
+
+export default class NetworkChart extends Chart<NetworkLog> {
+	constructor() {
+		super(name, schema);
+	}
+
+	@autobind
+	protected genNewLog(latest: NetworkLog): DeepPartial<NetworkLog> {
+		return {};
+	}
+
+	@autobind
+	protected async fetchActual(): Promise<DeepPartial<NetworkLog>> {
+		return {};
+	}
+
+	@autobind
+	public async update(incomingRequests: number, time: number, incomingBytes: number, outgoingBytes: number) {
+		const inc: DeepPartial<NetworkLog> = {
+			incomingRequests: incomingRequests,
+			totalTime: time,
+			incomingBytes: incomingBytes,
+			outgoingBytes: outgoingBytes
+		};
+
+		await this.inc(inc);
+	}
+}
diff --git a/src/services/chart/charts/classes/notes.ts b/src/services/chart/charts/classes/notes.ts
new file mode 100644
index 0000000000..85ccf000d8
--- /dev/null
+++ b/src/services/chart/charts/classes/notes.ts
@@ -0,0 +1,71 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { Notes } from '../../../../models';
+import { Not } from 'typeorm';
+import { Note } from '../../../../models/entities/note';
+import { name, schema } from '../schemas/notes';
+
+type NotesLog = SchemaType<typeof schema>;
+
+export default class NotesChart extends Chart<NotesLog> {
+	constructor() {
+		super(name, schema);
+	}
+
+	@autobind
+	protected genNewLog(latest: NotesLog): DeepPartial<NotesLog> {
+		return {
+			local: {
+				total: latest.local.total,
+			},
+			remote: {
+				total: latest.remote.total,
+			}
+		};
+	}
+
+	@autobind
+	protected async fetchActual(): Promise<DeepPartial<NotesLog>> {
+		const [localCount, remoteCount] = await Promise.all([
+			Notes.count({ userHost: null }),
+			Notes.count({ userHost: Not(null) })
+		]);
+
+		return {
+			local: {
+				total: localCount,
+			},
+			remote: {
+				total: remoteCount,
+			}
+		};
+	}
+
+	@autobind
+	public async update(note: Note, isAdditional: boolean) {
+		const update: Obj = {
+			diffs: {}
+		};
+
+		update.total = isAdditional ? 1 : -1;
+
+		if (isAdditional) {
+			update.inc = 1;
+		} else {
+			update.dec = 1;
+		}
+
+		if (note.replyId != null) {
+			update.diffs.reply = isAdditional ? 1 : -1;
+		} else if (note.renoteId != null) {
+			update.diffs.renote = isAdditional ? 1 : -1;
+		} else {
+			update.diffs.normal = isAdditional ? 1 : -1;
+		}
+
+		await this.inc({
+			[note.userHost === null ? 'local' : 'remote']: update
+		});
+	}
+}
diff --git a/src/services/chart/charts/classes/per-user-drive.ts b/src/services/chart/charts/classes/per-user-drive.ts
new file mode 100644
index 0000000000..822f4eda0f
--- /dev/null
+++ b/src/services/chart/charts/classes/per-user-drive.ts
@@ -0,0 +1,52 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { DriveFiles } from '../../../../models';
+import { DriveFile } from '../../../../models/entities/drive-file';
+import { name, schema } from '../schemas/per-user-drive';
+
+type PerUserDriveLog = SchemaType<typeof schema>;
+
+export default class PerUserDriveChart extends Chart<PerUserDriveLog> {
+	constructor() {
+		super(name, schema, true);
+	}
+
+	@autobind
+	protected genNewLog(latest: PerUserDriveLog): DeepPartial<PerUserDriveLog> {
+		return {
+			totalCount: latest.totalCount,
+			totalSize: latest.totalSize,
+		};
+	}
+
+	@autobind
+	protected async fetchActual(group: string): Promise<DeepPartial<PerUserDriveLog>> {
+		const [count, size] = await Promise.all([
+			DriveFiles.count({ userId: group }),
+			DriveFiles.clacDriveUsageOf(group)
+		]);
+
+		return {
+			totalCount: count,
+			totalSize: size,
+		};
+	}
+
+	@autobind
+	public async update(file: DriveFile, isAdditional: boolean) {
+		const update: Obj = {};
+
+		update.totalCount = isAdditional ? 1 : -1;
+		update.totalSize = isAdditional ? file.size : -file.size;
+		if (isAdditional) {
+			update.incCount = 1;
+			update.incSize = file.size;
+		} else {
+			update.decCount = 1;
+			update.decSize = file.size;
+		}
+
+		await this.inc(update, file.userId);
+	}
+}
diff --git a/src/services/chart/charts/classes/per-user-following.ts b/src/services/chart/charts/classes/per-user-following.ts
new file mode 100644
index 0000000000..f3809a7c94
--- /dev/null
+++ b/src/services/chart/charts/classes/per-user-following.ts
@@ -0,0 +1,91 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { Followings, Users } from '../../../../models';
+import { Not } from 'typeorm';
+import { User } from '../../../../models/entities/user';
+import { name, schema } from '../schemas/per-user-following';
+
+type PerUserFollowingLog = SchemaType<typeof schema>;
+
+export default class PerUserFollowingChart extends Chart<PerUserFollowingLog> {
+	constructor() {
+		super(name, schema, true);
+	}
+
+	@autobind
+	protected genNewLog(latest: PerUserFollowingLog): DeepPartial<PerUserFollowingLog> {
+		return {
+			local: {
+				followings: {
+					total: latest.local.followings.total,
+				},
+				followers: {
+					total: latest.local.followers.total,
+				}
+			},
+			remote: {
+				followings: {
+					total: latest.remote.followings.total,
+				},
+				followers: {
+					total: latest.remote.followers.total,
+				}
+			}
+		};
+	}
+
+	@autobind
+	protected async fetchActual(group: string): Promise<DeepPartial<PerUserFollowingLog>> {
+		const [
+			localFollowingsCount,
+			localFollowersCount,
+			remoteFollowingsCount,
+			remoteFollowersCount
+		] = await Promise.all([
+			Followings.count({ followerId: group, followeeHost: null }),
+			Followings.count({ followeeId: group, followerHost: null }),
+			Followings.count({ followerId: group, followeeHost: Not(null) }),
+			Followings.count({ followeeId: group, followerHost: Not(null) })
+		]);
+
+		return {
+			local: {
+				followings: {
+					total: localFollowingsCount,
+				},
+				followers: {
+					total: localFollowersCount,
+				}
+			},
+			remote: {
+				followings: {
+					total: remoteFollowingsCount,
+				},
+				followers: {
+					total: remoteFollowersCount,
+				}
+			}
+		};
+	}
+
+	@autobind
+	public async update(follower: User, followee: User, isFollow: boolean) {
+		const update: Obj = {};
+
+		update.total = isFollow ? 1 : -1;
+
+		if (isFollow) {
+			update.inc = 1;
+		} else {
+			update.dec = 1;
+		}
+
+		this.inc({
+			[Users.isLocalUser(follower) ? 'local' : 'remote']: { followings: update }
+		}, follower.id);
+		this.inc({
+			[Users.isLocalUser(followee) ? 'local' : 'remote']: { followers: update }
+		}, followee.id);
+	}
+}
diff --git a/src/services/chart/charts/classes/per-user-notes.ts b/src/services/chart/charts/classes/per-user-notes.ts
new file mode 100644
index 0000000000..cccd495604
--- /dev/null
+++ b/src/services/chart/charts/classes/per-user-notes.ts
@@ -0,0 +1,58 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { User } from '../../../../models/entities/user';
+import { SchemaType } from '../../../../misc/schema';
+import { Notes } from '../../../../models';
+import { Note } from '../../../../models/entities/note';
+import { name, schema } from '../schemas/per-user-notes';
+
+type PerUserNotesLog = SchemaType<typeof schema>;
+
+export default class PerUserNotesChart extends Chart<PerUserNotesLog> {
+	constructor() {
+		super(name, schema, true);
+	}
+
+	@autobind
+	protected genNewLog(latest: PerUserNotesLog): DeepPartial<PerUserNotesLog> {
+		return {
+			total: latest.total,
+		};
+	}
+
+	@autobind
+	protected async fetchActual(group: string): Promise<DeepPartial<PerUserNotesLog>> {
+		const [count] = await Promise.all([
+			Notes.count({ userId: group }),
+		]);
+
+		return {
+			total: count,
+		};
+	}
+
+	@autobind
+	public async update(user: User, note: Note, isAdditional: boolean) {
+		const update: Obj = {
+			diffs: {}
+		};
+
+		update.total = isAdditional ? 1 : -1;
+
+		if (isAdditional) {
+			update.inc = 1;
+		} else {
+			update.dec = 1;
+		}
+
+		if (note.replyId != null) {
+			update.diffs.reply = isAdditional ? 1 : -1;
+		} else if (note.renoteId != null) {
+			update.diffs.renote = isAdditional ? 1 : -1;
+		} else {
+			update.diffs.normal = isAdditional ? 1 : -1;
+		}
+
+		await this.inc(update, user.id);
+	}
+}
diff --git a/src/services/chart/charts/classes/per-user-reactions.ts b/src/services/chart/charts/classes/per-user-reactions.ts
new file mode 100644
index 0000000000..124fb4153c
--- /dev/null
+++ b/src/services/chart/charts/classes/per-user-reactions.ts
@@ -0,0 +1,32 @@
+import autobind from 'autobind-decorator';
+import Chart, { DeepPartial } from '../../core';
+import { User } from '../../../../models/entities/user';
+import { Note } from '../../../../models/entities/note';
+import { SchemaType } from '../../../../misc/schema';
+import { Users } from '../../../../models';
+import { name, schema } from '../schemas/per-user-reactions';
+
+type PerUserReactionsLog = SchemaType<typeof schema>;
+
+export default class PerUserReactionsChart extends Chart<PerUserReactionsLog> {
+	constructor() {
+		super(name, schema, true);
+	}
+
+	@autobind
+	protected genNewLog(latest: PerUserReactionsLog): DeepPartial<PerUserReactionsLog> {
+		return {};
+	}
+
+	@autobind
+	protected async fetchActual(group: string): Promise<DeepPartial<PerUserReactionsLog>> {
+		return {};
+	}
+
+	@autobind
+	public async update(user: User, note: Note) {
+		this.inc({
+			[Users.isLocalUser(user) ? 'local' : 'remote']: { count: 1 }
+		}, note.userId);
+	}
+}
diff --git a/src/services/chart/charts/classes/test-grouped.ts b/src/services/chart/charts/classes/test-grouped.ts
new file mode 100644
index 0000000000..e32cbcf416
--- /dev/null
+++ b/src/services/chart/charts/classes/test-grouped.ts
@@ -0,0 +1,47 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { name, schema } from '../schemas/test-grouped';
+
+type TestGroupedLog = SchemaType<typeof schema>;
+
+export default class TestGroupedChart extends Chart<TestGroupedLog> {
+	private total = {} as Record<string, number>;
+
+	constructor() {
+		super(name, schema, true);
+	}
+
+	@autobind
+	protected genNewLog(latest: TestGroupedLog): DeepPartial<TestGroupedLog> {
+		return {
+			foo: {
+				total: latest.foo.total,
+			},
+		};
+	}
+
+	@autobind
+	protected async fetchActual(group: string): Promise<DeepPartial<TestGroupedLog>> {
+		return {
+			foo: {
+				total: this.total[group],
+			},
+		};
+	}
+
+	@autobind
+	public async increment(group: string) {
+		if (this.total[group] == null) this.total[group] = 0;
+
+		const update: Obj = {};
+
+		update.total = 1;
+		update.inc = 1;
+		this.total[group]++;
+
+		await this.inc({
+			foo: update
+		}, group);
+	}
+}
diff --git a/src/services/chart/charts/classes/test-unique.ts b/src/services/chart/charts/classes/test-unique.ts
new file mode 100644
index 0000000000..1eb396c293
--- /dev/null
+++ b/src/services/chart/charts/classes/test-unique.ts
@@ -0,0 +1,29 @@
+import autobind from 'autobind-decorator';
+import Chart, { DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { name, schema } from '../schemas/test-unique';
+
+type TestUniqueLog = SchemaType<typeof schema>;
+
+export default class TestUniqueChart extends Chart<TestUniqueLog> {
+	constructor() {
+		super(name, schema);
+	}
+
+	@autobind
+	protected genNewLog(latest: TestUniqueLog): DeepPartial<TestUniqueLog> {
+		return {};
+	}
+
+	@autobind
+	protected async fetchActual(): Promise<DeepPartial<TestUniqueLog>> {
+		return {};
+	}
+
+	@autobind
+	public async uniqueIncrement(key: string) {
+		await this.incIfUnique({
+			foo: 1
+		}, 'foos', key);
+	}
+}
diff --git a/src/services/chart/charts/classes/test.ts b/src/services/chart/charts/classes/test.ts
new file mode 100644
index 0000000000..57c22822f2
--- /dev/null
+++ b/src/services/chart/charts/classes/test.ts
@@ -0,0 +1,45 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { name, schema } from '../schemas/test';
+
+type TestLog = SchemaType<typeof schema>;
+
+export default class TestChart extends Chart<TestLog> {
+	private total = 0;
+
+	constructor() {
+		super(name, schema);
+	}
+
+	@autobind
+	protected genNewLog(latest: TestLog): DeepPartial<TestLog> {
+		return {
+			foo: {
+				total: latest.foo.total,
+			},
+		};
+	}
+
+	@autobind
+	protected async fetchActual(): Promise<DeepPartial<TestLog>> {
+		return {
+			foo: {
+				total: this.total,
+			},
+		};
+	}
+
+	@autobind
+	public async increment() {
+		const update: Obj = {};
+
+		update.total = 1;
+		update.inc = 1;
+		this.total++;
+
+		await this.inc({
+			foo: update
+		});
+	}
+}
diff --git a/src/services/chart/charts/classes/users.ts b/src/services/chart/charts/classes/users.ts
new file mode 100644
index 0000000000..eec30de8dc
--- /dev/null
+++ b/src/services/chart/charts/classes/users.ts
@@ -0,0 +1,60 @@
+import autobind from 'autobind-decorator';
+import Chart, { Obj, DeepPartial } from '../../core';
+import { SchemaType } from '../../../../misc/schema';
+import { Users } from '../../../../models';
+import { Not } from 'typeorm';
+import { User } from '../../../../models/entities/user';
+import { name, schema } from '../schemas/users';
+
+type UsersLog = SchemaType<typeof schema>;
+
+export default class UsersChart extends Chart<UsersLog> {
+	constructor() {
+		super(name, schema);
+	}
+
+	@autobind
+	protected genNewLog(latest: UsersLog): DeepPartial<UsersLog> {
+		return {
+			local: {
+				total: latest.local.total,
+			},
+			remote: {
+				total: latest.remote.total,
+			}
+		};
+	}
+
+	@autobind
+	protected async fetchActual(): Promise<DeepPartial<UsersLog>> {
+		const [localCount, remoteCount] = await Promise.all([
+			Users.count({ host: null }),
+			Users.count({ host: Not(null) })
+		]);
+
+		return {
+			local: {
+				total: localCount,
+			},
+			remote: {
+				total: remoteCount,
+			}
+		};
+	}
+
+	@autobind
+	public async update(user: User, isAdditional: boolean) {
+		const update: Obj = {};
+
+		update.total = isAdditional ? 1 : -1;
+		if (isAdditional) {
+			update.inc = 1;
+		} else {
+			update.dec = 1;
+		}
+
+		await this.inc({
+			[Users.isLocalUser(user) ? 'local' : 'remote']: update
+		});
+	}
+}