chore: release v0.0.32

.gitignore

@@ -3,6 +3,7 @@ out
 dist
 tmp
 lib
+data
 
 .vscode
 .env
@@ -22,4 +23,5 @@ src/update.ini
 !eslint.config.js
 
 coverage
-*.tsbuildinfo
+*.tsbuildinfo
+.DS_Store

.prettierignore

@@ -1,2 +1,3 @@
 *.js
-*.ts
+*.ts
+*.json

apps/api-master/drizzle.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+	dbCredentials: {
+		url: "postgresql://metrics:metrics@localhost:5432/metrics",
+	},
+	dialect: "postgresql",
+	schema: "./src/db.ts",
+	out: "./drizzle",
+});

apps/api-master/drizzle/0000_flippant_marrow.sql

@@ -0,0 +1,9 @@
+CREATE TABLE IF NOT EXISTS "online_users_ip_data" (
+	"uuid" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"ip" varchar(45) NOT NULL,
+	"country" varchar(2) NOT NULL,
+	"latitude" numeric(10, 8) NOT NULL,
+	"longitude" numeric(11, 8) NOT NULL,
+	"name" varchar(255),
+	"timestamp" timestamp DEFAULT now()
+);

apps/api-master/drizzle/0001_white_lifeguard.sql

@@ -0,0 +1,2 @@
+CREATE INDEX IF NOT EXISTS "idx_online_users_uuid" ON "online_users_ip_data" USING btree ("uuid");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "idx_online_users_timestamp" ON "online_users_ip_data" USING btree ("timestamp");

apps/api-master/drizzle/0002_new_darkhawk.sql

@@ -0,0 +1 @@
+ALTER TABLE "online_users_ip_data" ALTER COLUMN "timestamp" SET DATA TYPE timestamp with time zone;

apps/api-master/drizzle/0003_narrow_mastermind.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "online_users_ip_data" ADD COLUMN "presences" jsonb DEFAULT '[]' NOT NULL;--> statement-breakpoint
+ALTER TABLE "online_users_ip_data" DROP COLUMN IF EXISTS "name";

apps/api-master/drizzle/0004_tiresome_puff_adder.sql

@@ -0,0 +1 @@
+ALTER TABLE "online_users_ip_data" ADD COLUMN "sessions" integer DEFAULT 0 NOT NULL;

apps/api-master/drizzle/meta/0000_snapshot.json

@@ -0,0 +1,70 @@
+{
+	"id": "e29a6708-01f1-455a-b345-63dac1e124dc",
+	"prevId": "00000000-0000-0000-0000-000000000000",
+	"version": "7",
+	"dialect": "postgresql",
+	"tables": {
+		"public.online_users_ip_data": {
+			"name": "online_users_ip_data",
+			"schema": "",
+			"columns": {
+				"uuid": {
+					"name": "uuid",
+					"type": "uuid",
+					"primaryKey": true,
+					"notNull": true,
+					"default": "gen_random_uuid()"
+				},
+				"ip": {
+					"name": "ip",
+					"type": "varchar(45)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"country": {
+					"name": "country",
+					"type": "varchar(2)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"latitude": {
+					"name": "latitude",
+					"type": "numeric(10, 8)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"longitude": {
+					"name": "longitude",
+					"type": "numeric(11, 8)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"name": {
+					"name": "name",
+					"type": "varchar(255)",
+					"primaryKey": false,
+					"notNull": false
+				},
+				"timestamp": {
+					"name": "timestamp",
+					"type": "timestamp",
+					"primaryKey": false,
+					"notNull": false,
+					"default": "now()"
+				}
+			},
+			"indexes": {},
+			"foreignKeys": {},
+			"compositePrimaryKeys": {},
+			"uniqueConstraints": {}
+		}
+	},
+	"enums": {},
+	"schemas": {},
+	"sequences": {},
+	"_meta": {
+		"columns": {},
+		"schemas": {},
+		"tables": {}
+	}
+}

apps/api-master/drizzle/meta/0001_snapshot.json

@@ -0,0 +1,101 @@
+{
+	"id": "4aa32a8e-f573-43b9-976a-2d078a0df0ea",
+	"prevId": "e29a6708-01f1-455a-b345-63dac1e124dc",
+	"version": "7",
+	"dialect": "postgresql",
+	"tables": {
+		"public.online_users_ip_data": {
+			"name": "online_users_ip_data",
+			"schema": "",
+			"columns": {
+				"uuid": {
+					"name": "uuid",
+					"type": "uuid",
+					"primaryKey": true,
+					"notNull": true,
+					"default": "gen_random_uuid()"
+				},
+				"ip": {
+					"name": "ip",
+					"type": "varchar(45)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"country": {
+					"name": "country",
+					"type": "varchar(2)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"latitude": {
+					"name": "latitude",
+					"type": "numeric(10, 8)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"longitude": {
+					"name": "longitude",
+					"type": "numeric(11, 8)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"name": {
+					"name": "name",
+					"type": "varchar(255)",
+					"primaryKey": false,
+					"notNull": false
+				},
+				"timestamp": {
+					"name": "timestamp",
+					"type": "timestamp",
+					"primaryKey": false,
+					"notNull": false,
+					"default": "now()"
+				}
+			},
+			"indexes": {
+				"idx_online_users_uuid": {
+					"name": "idx_online_users_uuid",
+					"columns": [
+						{
+							"expression": "uuid",
+							"isExpression": false,
+							"asc": true,
+							"nulls": "last"
+						}
+					],
+					"isUnique": false,
+					"concurrently": false,
+					"method": "btree",
+					"with": {}
+				},
+				"idx_online_users_timestamp": {
+					"name": "idx_online_users_timestamp",
+					"columns": [
+						{
+							"expression": "timestamp",
+							"isExpression": false,
+							"asc": true,
+							"nulls": "last"
+						}
+					],
+					"isUnique": false,
+					"concurrently": false,
+					"method": "btree",
+					"with": {}
+				}
+			},
+			"foreignKeys": {},
+			"compositePrimaryKeys": {},
+			"uniqueConstraints": {}
+		}
+	},
+	"enums": {},
+	"schemas": {},
+	"sequences": {},
+	"_meta": {
+		"columns": {},
+		"schemas": {},
+		"tables": {}
+	}
+}

apps/api-master/drizzle/meta/0002_snapshot.json

@@ -0,0 +1,101 @@
+{
+	"id": "c1b8dbed-b232-4d66-9e74-b9af333095bc",
+	"prevId": "4aa32a8e-f573-43b9-976a-2d078a0df0ea",
+	"version": "7",
+	"dialect": "postgresql",
+	"tables": {
+		"public.online_users_ip_data": {
+			"name": "online_users_ip_data",
+			"schema": "",
+			"columns": {
+				"uuid": {
+					"name": "uuid",
+					"type": "uuid",
+					"primaryKey": true,
+					"notNull": true,
+					"default": "gen_random_uuid()"
+				},
+				"ip": {
+					"name": "ip",
+					"type": "varchar(45)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"country": {
+					"name": "country",
+					"type": "varchar(2)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"latitude": {
+					"name": "latitude",
+					"type": "numeric(10, 8)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"longitude": {
+					"name": "longitude",
+					"type": "numeric(11, 8)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"name": {
+					"name": "name",
+					"type": "varchar(255)",
+					"primaryKey": false,
+					"notNull": false
+				},
+				"timestamp": {
+					"name": "timestamp",
+					"type": "timestamp with time zone",
+					"primaryKey": false,
+					"notNull": false,
+					"default": "now()"
+				}
+			},
+			"indexes": {
+				"idx_online_users_uuid": {
+					"name": "idx_online_users_uuid",
+					"columns": [
+						{
+							"expression": "uuid",
+							"isExpression": false,
+							"asc": true,
+							"nulls": "last"
+						}
+					],
+					"isUnique": false,
+					"concurrently": false,
+					"method": "btree",
+					"with": {}
+				},
+				"idx_online_users_timestamp": {
+					"name": "idx_online_users_timestamp",
+					"columns": [
+						{
+							"expression": "timestamp",
+							"isExpression": false,
+							"asc": true,
+							"nulls": "last"
+						}
+					],
+					"isUnique": false,
+					"concurrently": false,
+					"method": "btree",
+					"with": {}
+				}
+			},
+			"foreignKeys": {},
+			"compositePrimaryKeys": {},
+			"uniqueConstraints": {}
+		}
+	},
+	"enums": {},
+	"schemas": {},
+	"sequences": {},
+	"_meta": {
+		"columns": {},
+		"schemas": {},
+		"tables": {}
+	}
+}

apps/api-master/drizzle/meta/0003_snapshot.json

@@ -0,0 +1,102 @@
+{
+	"id": "e409a4d0-f698-484a-b412-38966a7b3a19",
+	"prevId": "c1b8dbed-b232-4d66-9e74-b9af333095bc",
+	"version": "7",
+	"dialect": "postgresql",
+	"tables": {
+		"public.online_users_ip_data": {
+			"name": "online_users_ip_data",
+			"schema": "",
+			"columns": {
+				"uuid": {
+					"name": "uuid",
+					"type": "uuid",
+					"primaryKey": true,
+					"notNull": true,
+					"default": "gen_random_uuid()"
+				},
+				"ip": {
+					"name": "ip",
+					"type": "varchar(45)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"country": {
+					"name": "country",
+					"type": "varchar(2)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"latitude": {
+					"name": "latitude",
+					"type": "numeric(10, 8)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"longitude": {
+					"name": "longitude",
+					"type": "numeric(11, 8)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"presences": {
+					"name": "presences",
+					"type": "jsonb",
+					"primaryKey": false,
+					"notNull": true,
+					"default": "'[]'"
+				},
+				"timestamp": {
+					"name": "timestamp",
+					"type": "timestamp with time zone",
+					"primaryKey": false,
+					"notNull": false,
+					"default": "now()"
+				}
+			},
+			"indexes": {
+				"idx_online_users_uuid": {
+					"name": "idx_online_users_uuid",
+					"columns": [
+						{
+							"expression": "uuid",
+							"isExpression": false,
+							"asc": true,
+							"nulls": "last"
+						}
+					],
+					"isUnique": false,
+					"concurrently": false,
+					"method": "btree",
+					"with": {}
+				},
+				"idx_online_users_timestamp": {
+					"name": "idx_online_users_timestamp",
+					"columns": [
+						{
+							"expression": "timestamp",
+							"isExpression": false,
+							"asc": true,
+							"nulls": "last"
+						}
+					],
+					"isUnique": false,
+					"concurrently": false,
+					"method": "btree",
+					"with": {}
+				}
+			},
+			"foreignKeys": {},
+			"compositePrimaryKeys": {},
+			"uniqueConstraints": {}
+		}
+	},
+	"enums": {},
+	"schemas": {},
+	"sequences": {},
+	"_meta": {
+		"columns": {},
+		"schemas": {},
+		"tables": {}
+	}
+}

apps/api-master/drizzle/meta/0004_snapshot.json

@@ -0,0 +1,109 @@
+{
+	"id": "179435b5-dc15-4a42-9539-c3f336699d63",
+	"prevId": "e409a4d0-f698-484a-b412-38966a7b3a19",
+	"version": "7",
+	"dialect": "postgresql",
+	"tables": {
+		"public.online_users_ip_data": {
+			"name": "online_users_ip_data",
+			"schema": "",
+			"columns": {
+				"uuid": {
+					"name": "uuid",
+					"type": "uuid",
+					"primaryKey": true,
+					"notNull": true,
+					"default": "gen_random_uuid()"
+				},
+				"ip": {
+					"name": "ip",
+					"type": "varchar(45)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"country": {
+					"name": "country",
+					"type": "varchar(2)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"latitude": {
+					"name": "latitude",
+					"type": "numeric(10, 8)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"longitude": {
+					"name": "longitude",
+					"type": "numeric(11, 8)",
+					"primaryKey": false,
+					"notNull": true
+				},
+				"sessions": {
+					"name": "sessions",
+					"type": "integer",
+					"primaryKey": false,
+					"notNull": true,
+					"default": 0
+				},
+				"presences": {
+					"name": "presences",
+					"type": "jsonb",
+					"primaryKey": false,
+					"notNull": true,
+					"default": "'[]'"
+				},
+				"timestamp": {
+					"name": "timestamp",
+					"type": "timestamp with time zone",
+					"primaryKey": false,
+					"notNull": false,
+					"default": "now()"
+				}
+			},
+			"indexes": {
+				"idx_online_users_uuid": {
+					"name": "idx_online_users_uuid",
+					"columns": [
+						{
+							"expression": "uuid",
+							"isExpression": false,
+							"asc": true,
+							"nulls": "last"
+						}
+					],
+					"isUnique": false,
+					"concurrently": false,
+					"method": "btree",
+					"with": {}
+				},
+				"idx_online_users_timestamp": {
+					"name": "idx_online_users_timestamp",
+					"columns": [
+						{
+							"expression": "timestamp",
+							"isExpression": false,
+							"asc": true,
+							"nulls": "last"
+						}
+					],
+					"isUnique": false,
+					"concurrently": false,
+					"method": "btree",
+					"with": {}
+				}
+			},
+			"foreignKeys": {},
+			"compositePrimaryKeys": {},
+			"uniqueConstraints": {}
+		}
+	},
+	"enums": {},
+	"schemas": {},
+	"sequences": {},
+	"_meta": {
+		"columns": {},
+		"schemas": {},
+		"tables": {}
+	}
+}

apps/api-master/drizzle/meta/_journal.json

@@ -0,0 +1,41 @@
+{
+	"version": "7",
+	"dialect": "postgresql",
+	"entries": [
+		{
+			"idx": 0,
+			"version": "7",
+			"when": 1726516195146,
+			"tag": "0000_flippant_marrow",
+			"breakpoints": true
+		},
+		{
+			"idx": 1,
+			"version": "7",
+			"when": 1726516348344,
+			"tag": "0001_white_lifeguard",
+			"breakpoints": true
+		},
+		{
+			"idx": 2,
+			"version": "7",
+			"when": 1726516660134,
+			"tag": "0002_new_darkhawk",
+			"breakpoints": true
+		},
+		{
+			"idx": 3,
+			"version": "7",
+			"when": 1726517073510,
+			"tag": "0003_narrow_mastermind",
+			"breakpoints": true
+		},
+		{
+			"idx": 4,
+			"version": "7",
+			"when": 1726517405363,
+			"tag": "0004_tiresome_puff_adder",
+			"breakpoints": true
+		}
+	]
+}

apps/api-master/environment.d.ts

@@ -0,0 +1,16 @@
+declare module "ip-location-api" {
+	export function lookup(ip: string): Promise<{
+		latitude: number;
+		longitude: number;
+		country: string;
+	} | null>;
+
+	export function updateDb(options: { fields?: string[]; dataDir?: string; tmpDataDir?: string; smallMemory?: boolean }): Promise<void>;
+	export function reload(options: { fields?: string[]; dataDir?: string; tmpDataDir?: string; smallMemory?: boolean }): Promise<void>;
+}
+
+declare namespace NodeJS {
+	export interface ProcessEnv {
+		METRICS_DATABASE_URL?: string;
+	}
+}

apps/api-master/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@premid/api-master",
 	"type": "module",
-	"version": "0.0.6",
+	"version": "0.0.32",
 	"private": true,
 	"description": "PreMiD's api master",
 	"license": "MPL-2.0",
@@ -11,17 +11,29 @@
 	],
 	"scripts": {
 		"start": "node --enable-source-maps .",
-		"dev": "node --watch --env-file .env --enable-source-maps ."
+		"dev": "node --watch --env-file .env --enable-source-maps .",
+		"db:generate": "drizzle-kit generate",
+		"db:migrate": "drizzle-kit migrate",
+		"db:update": "pnpm db:generate && pnpm db:migrate",
+		"db:studio": "drizzle-kit studio"
 	},
 	"dependencies": {
-		"@discordjs/rest": "^2.3.0",
 		"@envelop/sentry": "^9.0.0",
+		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/exporter-prometheus": "^0.52.1",
+		"@opentelemetry/node": "^0.24.0",
 		"@sentry/node": "^8.17.0",
 		"cron": "^3.1.7",
 		"debug": "^4.3.6",
-		"ioredis": "^5.3.2"
+		"drizzle-orm": "^0.33.0",
+		"ioredis": "^5.3.2",
+		"ip-location-api": "^1.0.0",
+		"ky": "^1.7.2",
+		"p-limit": "^6.1.0",
+		"postgres": "^3.4.4"
 	},
 	"devDependencies": {
-		"@types/debug": "^4.1.12"
+		"@types/debug": "^4.1.12",
+		"drizzle-kit": "^0.24.2"
 	}
 }

apps/api-master/src/db.ts

@@ -0,0 +1,27 @@
+import process from "node:process";
+import { decimal, index, integer, jsonb, pgTable, timestamp, uuid, varchar } from "drizzle-orm/pg-core";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+// Define the schema
+export const onlineUsersIpData = pgTable("online_users_ip_data", {
+	uuid: uuid("uuid").primaryKey().defaultRandom(),
+	ip: varchar("ip", { length: 45 }).notNull(),
+	country: varchar("country", { length: 2 }).notNull(),
+	latitude: decimal("latitude", { precision: 10, scale: 8 }).notNull(),
+	longitude: decimal("longitude", { precision: 11, scale: 8 }).notNull(),
+	sessions: integer("sessions").notNull().default(0),
+	presences: jsonb("presences").notNull().default("[]").$type<string[]>(),
+	timestamp: timestamp("timestamp", { withTimezone: true }).defaultNow(),
+}, table => ({
+	idxOnlineUsersUuid: index("idx_online_users_uuid").on(table.uuid),
+	idxOnlineUsersTimestamp: index("idx_online_users_timestamp").on(table.timestamp),
+}));
+
+if (!process.env.METRICS_DATABASE_URL) {
+	throw new Error("METRICS_DATABASE_URL is not set");
+}
+
+export const sql = postgres(process.env.METRICS_DATABASE_URL);
+
+export const db = drizzle(sql);

apps/api-master/src/functions/cleanupOldUserData.ts

@@ -0,0 +1,10 @@
+import { lt, sql } from "drizzle-orm";
+import { db, onlineUsersIpData } from "../db.js";
+import { mainLog } from "../index.js";
+
+export async function cleanupOldUserData(retentionDays: number) {
+	mainLog("Cleaning up old user ip data");
+	const interval = `'${retentionDays} days'`;
+	await db.delete(onlineUsersIpData)
+		.where(lt(onlineUsersIpData.timestamp, sql`now() - interval ${sql.raw(interval)}`));
+}

apps/api-master/src/functions/clearOldSessions.ts

@@ -1,46 +1,100 @@
-import { REST } from "@discordjs/rest";
+import pLimit from "p-limit";
+import ky, { HTTPError, TimeoutError } from "ky";
 import { mainLog, redis } from "../index.js";
 
+let inProgress = false;
 export async function clearOldSessions() {
-	const sessions = await redis.hgetall("pmd-api.sessions");
-	const now = Date.now();
-
-	if (Object.keys(sessions).length === 0) {
-		mainLog("No sessions to clear");
+	if (inProgress) {
+		mainLog("Session cleanup already in progress");
 		return;
 	}
 
-	mainLog(`Checking ${Object.keys(sessions).length} sessions`);
-
+	inProgress = true;
+	const now = Date.now();
+	const pattern = "pmd-api.sessions.*";
+	let cursor = "0";
+	let totalSessions = 0;
 	let cleared = 0;
-	for (const [key, value] of Object.entries(sessions)) {
-		const session = JSON.parse(value) as {
-			token: string;
-			session: string;
-			lastUpdated: number;
-		};
+	const batchSize = 100;
+	let keysToDelete: string[] = [];
 
-		// ? If the session is younger than 30seconds, skip it
-		if (now - session.lastUpdated < 30000)
-			continue;
+	mainLog("Starting session cleanup");
 
-		//* Delete the session
-		try {
-			const discord = new REST({ version: "10", authPrefix: "Bearer" });
-			discord.setToken(session.token);
-			await discord.post("/users/@me/headless-sessions/delete", {
-				body: {
-					token: session.session,
-				},
-			});
-		}
-		catch (error) {
-			mainLog(`Failed to delete session: %O`, error);
+	const limit = pLimit(100); // Create a limit of 100 concurrent operations
+
+	do {
+		const [newCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 1000); //* Use SCAN with COUNT for memory efficiency
+
+		cursor = newCursor;
+		totalSessions += keys.length;
+
+		const deletePromises: Promise<string>[] = [];
+
+		for (const key of keys) {
+			const session = await redis.hgetall(key) as unknown as {
+				token: string;
+				session: string;
+				lastUpdated: number;
+			};
+
+			if (now - session.lastUpdated < 30000)
+				continue;
+
+			deletePromises.push(limit(() => deleteSession(session, key)));
 		}
 
-		cleared++;
-		await redis.hdel("pmd-api.sessions", key);
+		const results = await Promise.allSettled(deletePromises);
+		results.forEach((result) => {
+			if (result.status === "fulfilled" && result.value) {
+				keysToDelete.push(result.value);
+				cleared++;
+			}
+		});
+
+		if (keysToDelete.length >= batchSize) {
+			await redis.del(...keysToDelete);
+			keysToDelete = [];
+		}
+	} while (cursor !== "0");
+
+	if (keysToDelete.length > 0) {
+		await redis.del(...keysToDelete);
 	}
 
-	mainLog(`Cleared ${cleared} sessions`);
+	if (totalSessions === 0) {
+		mainLog("No sessions to clear");
+	}
+	else {
+		mainLog(`Checked ${totalSessions} sessions, cleared ${cleared}`);
+	}
+
+	inProgress = false;
+}
+
+async function deleteSession(session: { token: string; session: string }, key: string): Promise<string> {
+	try {
+		await ky.post("https://discord.com/api/v10/users/@me/headless-sessions/delete", {
+			json: {
+				token: session.session,
+			},
+			headers: {
+				Authorization: `Bearer ${session.token}`,
+			},
+			retry: 3,
+			timeout: 5000,
+		});
+	}
+	catch (error) {
+		if (error instanceof TimeoutError) {
+			mainLog(`Session deletion aborted due to timeout for key ${key}`);
+		}
+		else if (error instanceof HTTPError) {
+			mainLog(`Failed to delete session for key ${key}: [${error.name}] ${error.message} ${JSON.stringify(await error.response.json())}`);
+		}
+		else {
+			mainLog(`Failed to delete session for key ${key}: Unknown error`);
+		}
+	}
+
+	return key;
 }

apps/api-master/src/functions/clearableGaugeMetric.ts

@@ -0,0 +1,83 @@
+import type { ServerResponse } from "node:http";
+import type { Attributes } from "@opentelemetry/api";
+import { ValueType, diag } from "@opentelemetry/api";
+import type { PrometheusExporter, PrometheusSerializer } from "@opentelemetry/exporter-prometheus";
+import { AggregationTemporality, DataPointType, type GaugeMetricData, InstrumentType } from "@opentelemetry/sdk-metrics";
+
+const registeredMetrics = new Map<string, ClearableGaugeMetric>();
+
+//* Custom gauge metric class
+export class ClearableGaugeMetric {
+	private data = new Map<string, { value: number; attributes: Attributes }>();
+
+	constructor(private readonly name: string, private readonly description: string) {
+		registeredMetrics.set(name, this);
+	}
+
+	set(key: string, value: number, attributes: Attributes) {
+		this.data.set(key, { value, attributes });
+	}
+
+	clear({ except }: { except?: string[] }) {
+		for (const key of this.data.keys()) {
+			if (except && except.includes(key))
+				continue;
+
+			this.data.delete(key);
+		}
+	}
+
+	toMetricData(): GaugeMetricData {
+		return {
+			descriptor: {
+				name: this.name,
+				description: this.description,
+				unit: "",
+				type: InstrumentType.GAUGE,
+				valueType: ValueType.INT,
+			},
+			dataPointType: DataPointType.GAUGE,
+			dataPoints: Array.from(this.data.values()).map(({ value, attributes }) => ({
+				value,
+				attributes,
+				startTime: [0, 0],
+				endTime: [0, 0],
+			})),
+			aggregationTemporality: AggregationTemporality.CUMULATIVE,
+		};
+	}
+
+	get hasData() {
+		return this.data.size > 0;
+	}
+}
+
+export function updatePrometheusMetrics(prometheusExporter: PrometheusExporter) {
+	// @ts-expect-error We are modifying a private method
+	prometheusExporter._exportMetrics = function (this: PrometheusExporter, response: ServerResponse) {
+		response.statusCode = 200;
+		response.setHeader("content-type", "text/plain");
+		this.collect().then(
+			(collectionResult) => {
+				const { resourceMetrics, errors } = collectionResult;
+				if (errors.length) {
+					diag.error(
+						"PrometheusExporter: metrics collection errors",
+						...errors,
+					);
+				}
+
+				for (const metric of registeredMetrics.values()) {
+					if (metric.hasData) {
+						resourceMetrics.scopeMetrics[0]!.metrics.push(metric.toMetricData());
+					}
+				}
+
+				response.end((this as unknown as { _serializer: PrometheusSerializer })._serializer.serialize(resourceMetrics));
+			},
+			(err) => {
+				response.end(`# failed to export metrics: ${err}`);
+			},
+		);
+	}.bind(prometheusExporter);
+}

apps/api-master/src/functions/insertIpData.ts

@@ -0,0 +1,40 @@
+import type { InferInsertModel } from "drizzle-orm";
+import { db, onlineUsersIpData } from "../db.js";
+import { lookupIp } from "./lookupIp.js";
+
+const batchSize = 1000;
+
+export async function insertIpData(
+	data: Map<string, {
+		presences: string[];
+		sessions: number;
+	}>,
+) {
+	const timestamp = new Date();
+	const list = [...data.keys()];
+	//* Split into batches of batchSize
+	for (let i = 0; i < list.length; i += batchSize) {
+		const batch = list.slice(i, i + batchSize);
+		const mapped = await Promise.all(batch.map(async (ip) => {
+			const parsed = await lookupIp(ip);
+			if (parsed) {
+				const { presences, sessions } = data.get(ip)!;
+				return {
+					ip,
+					country: parsed.country,
+					latitude: parsed.latitude.toString(),
+					longitude: parsed.longitude.toString(),
+					presences,
+					sessions,
+					timestamp,
+				} satisfies InferInsertModel<typeof onlineUsersIpData>;
+			}
+		}));
+
+		const toInsert = mapped.filter(Boolean) as InferInsertModel<typeof onlineUsersIpData>[];
+
+		if (toInsert.length > 0) {
+			await db.insert(onlineUsersIpData).values(toInsert);
+		}
+	}
+}

apps/api-master/src/functions/lookupIp.ts

@@ -0,0 +1,47 @@
+import { join } from "node:path";
+import process from "node:process";
+import { lookup, reload, updateDb } from "ip-location-api";
+import { mainLog } from "../index.js";
+
+const fields = ["latitude", "longitude", "country"];
+
+const dataDir = join(process.cwd(), "data");
+const tmpDataDir = join(process.cwd(), "tmp");
+const smallMemory = true;
+
+let initialized = false;
+
+export async function lookupIp(ip: string): Promise<{ latitude: number; longitude: number; country: string } | undefined> {
+	if (!initialized) {
+		reloadIpLocationApi();
+		return undefined;
+	}
+	try {
+		return await lookup(ip) ?? undefined;
+	}
+	catch {
+		return undefined;
+	}
+}
+
+let reloading: Promise<void> | undefined = Promise.resolve();
+let log: debug.Debugger | undefined;
+
+export async function reloadIpLocationApi() {
+	log ??= mainLog.extend("IP-Location-API");
+
+	if (reloading)
+		return reloading;
+
+	reloading = new Promise((resolve, reject) => {
+		log?.("Reloading IP location API");
+		updateDb({ fields, dataDir, tmpDataDir, smallMemory }).then(async () => {
+			await reload({ fields, dataDir, tmpDataDir, smallMemory });
+			log?.("IP location API reloaded");
+			initialized = true;
+			reloading = undefined;
+			resolve();
+		}).catch(reject);
+	});
+	return reloading;
+}

apps/api-master/src/functions/setSessionCounter.ts

@@ -0,0 +1,13 @@
+import { redis } from "../index.js";
+import { activeSessionsCounter } from "../tracing.js";
+
+let activeActivities = 0;
+activeSessionsCounter.add(0);
+export async function setSessionCounter() {
+	const length = await redis.hlen("pmd-api.sessions");
+	if (length === activeActivities)
+		return;
+	const diff = length - activeActivities;
+	activeActivities = length;
+	activeSessionsCounter.add(diff);
+}

apps/api-master/src/functions/updateActivePresenceGauge.ts

@@ -0,0 +1,74 @@
+import pLimit from "p-limit";
+import { mainLog, redis } from "../index.js";
+import { activePresenceGauge } from "../tracing.js";
+import { insertIpData } from "./insertIpData.js";
+
+export const updateActivePresenceGaugeLimit = pLimit(1);
+let log: debug.Debugger | undefined;
+
+export async function updateActivePresenceGauge() {
+	await updateActivePresenceGaugeLimit(async () => {
+		log ??= mainLog.extend("Heartbeat-Updates");
+		log?.("Starting active presence gauge update");
+
+		const pattern = "pmd-api.heartbeatUpdates.*";
+		let cursor: string = "0";
+		const serviceCounts = new Map<string, number>();
+		const ips = new Map<string, {
+			presences: Set<string>;
+			sessions: number;
+		}>();
+
+		do {
+			const [newCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 1000);
+			cursor = newCursor;
+
+			//* Use pipelining for batch Redis operations
+			const pipeline = redis.pipeline();
+			keys.forEach(key => pipeline.hmget(key, "service", "version", "ip_address"));
+			const hashes = await pipeline.exec();
+
+			if (!hashes) {
+				log?.("No hashes found");
+				return;
+			}
+
+			hashes.forEach(([err, hash]) => {
+				if (err || !Array.isArray(hash))
+					return;
+
+				const [service, version, ip] = hash;
+				const serviceVersion = service && version ? `${service}:${version}` : "none";
+				serviceCounts.set(serviceVersion, (serviceCounts.get(serviceVersion) || 0) + 1);
+
+				if (ip) {
+					const ipData = ips.get(ip) || { presences: new Set(), sessions: 0 };
+					if (serviceVersion !== "none")
+						ipData.presences.add(serviceVersion);
+					ipData.sessions++;
+					ips.set(ip, ipData);
+				}
+			});
+		} while (cursor !== "0");
+
+		log?.("Updating active presence gauge");
+
+		//* Batch update the gauge
+		activePresenceGauge.clear({ except: [...serviceCounts.keys()] });
+		for (const [serviceVersion, count] of serviceCounts) {
+			const [presence_name, version] = serviceVersion.split(":");
+			activePresenceGauge.set(serviceVersion, count, { presence_name, version });
+		}
+
+		//* Convert IP data for insertion
+		const ipDataForInsertion = new Map(
+			Array.from(ips, ([ip, data]) => [ip, {
+				presences: Array.from(data.presences),
+				sessions: data.sessions,
+			}]),
+		);
+
+		await insertIpData(ipDataForInsertion);
+		log?.("Active presence gauge update completed");
+	});
+}

apps/api-master/src/index.ts

@@ -1,21 +1,61 @@
+import process from "node:process";
 import { CronJob } from "cron";
-
 import debug from "debug";
 import { clearOldSessions } from "./functions/clearOldSessions.js";
 import createRedis from "./functions/createRedis.js";
+import { setSessionCounter } from "./functions/setSessionCounter.js";
+import "./tracing.js";
+import { updateActivePresenceGauge, updateActivePresenceGaugeLimit } from "./functions/updateActivePresenceGauge.js";
+// import { reloadIpLocationApi } from "./functions/lookupIp.js";
+import { cleanupOldUserData } from "./functions/cleanupOldUserData.js";
 
 export const redis = createRedis();
 
 export const mainLog = debug("api-master");
 
-debug("Starting cron job to clear old sessions");
+debug("Starting cron jobs");
 
 void new CronJob(
 	// Every 5 seconds
 	"*/5 * * * * *",
-	async () => {
-		clearOldSessions();
+	() => {
+		if (process.env.DISABLE_CLEAR_OLD_SESSIONS !== "true") {
+			clearOldSessions();
+		}
+		if (process.env.DISABLE_SET_SESSION_COUNTER !== "true") {
+			setSessionCounter();
+		}
+		if (process.env.DISABLE_ACTIVE_PRESENCE_GAUGE !== "true") {
+			updateActivePresenceGaugeLimit.clearQueue();
+			updateActivePresenceGauge();
+		}
 	},
 	undefined,
 	true,
 );
+
+// void new CronJob(
+// 	// Every day at 9am
+// 	"0 9 * * *",
+// 	() => {
+// 		reloadIpLocationApi();
+// 	},
+// 	undefined,
+// 	true,
+// 	undefined,
+// 	undefined,
+// 	true,
+// );
+
+void new CronJob(
+	// Every day at 1am
+	"0 1 * * *",
+	() => {
+		cleanupOldUserData(14); // Keep 14 days of data
+	},
+	undefined,
+	true,
+	undefined,
+	undefined,
+	true,
+);

apps/api-master/src/tracing.ts

@@ -0,0 +1,26 @@
+import { ValueType } from "@opentelemetry/api";
+import { PrometheusExporter } from "@opentelemetry/exporter-prometheus";
+import { MeterProvider } from "@opentelemetry/sdk-metrics";
+import { ClearableGaugeMetric, updatePrometheusMetrics } from "./functions/clearableGaugeMetric.js";
+
+const prometheusExporter = new PrometheusExporter();
+
+const provider = new MeterProvider({
+	readers: [prometheusExporter],
+});
+
+const meter = provider.getMeter("nice");
+
+export const activeSessionsCounter = meter.createUpDownCounter("active_sessions", {
+	description: "Number of active sessions",
+	valueType: ValueType.INT,
+});
+
+export const activePresenceGauge = new ClearableGaugeMetric(
+	"active_presences",
+	"Per presence name+version, active number of users",
+);
+
+updatePrometheusMetrics(prometheusExporter);
+
+prometheusExporter.startServer();

apps/api-master/tsconfig.app.json

@@ -3,6 +3,7 @@
 	"compilerOptions": {
 		"composite": true,
 		"rootDir": "src",
+		"types": ["./environment.d.ts"],
 		"outDir": "dist"
 	},
 	"include": ["src/**/*"]

apps/api-worker/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@premid/api-worker",
 	"type": "module",
-	"version": "0.0.7",
+	"version": "0.0.14",
 	"private": true,
 	"description": "PreMiD's api",
 	"license": "MPL-2.0",

apps/api-worker/src/constants.ts

@@ -0,0 +1,10 @@
+import process from "node:process";
+import { defu } from "defu";
+
+const disabledFlags = process.env.DISABLED_FEATURE_FLAGS?.split(",") ?? [];
+const flags = Object.fromEntries(disabledFlags.map(flag => [flag, false]));
+
+export const featureFlags = defu(flags, {
+	WebSocketManager: true,
+	SessionKeepAlive: true,
+});

apps/api-worker/src/functions/createServer.ts

@@ -1,13 +1,10 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import process from "node:process";
-import { useSentry } from "@envelop/sentry";
 import { maxAliasesPlugin } from "@escape.tech/graphql-armor-max-aliases";
 import { maxDepthPlugin } from "@escape.tech/graphql-armor-max-depth";
 import { maxDirectivesPlugin } from "@escape.tech/graphql-armor-max-directives";
 import { maxTokensPlugin } from "@escape.tech/graphql-armor-max-tokens";
 import fastifyWebsocket from "@fastify/websocket";
-import { defu } from "defu";
 import fastify from "fastify";
 
 import { createSchema, createYoga } from "graphql-yoga";
@@ -15,6 +12,7 @@ import type { FastifyReply, FastifyRequest } from "fastify";
 import { Socket } from "../classes/Socket.js";
 import { resolvers } from "../graphql/resolvers/v5/index.js";
 import { sessionKeepAlive } from "../routes/sessionKeepAlive.js";
+import { featureFlags } from "../constants.js";
 import createRedis from "./createRedis.js";
 
 export interface FastifyContext {
@@ -48,7 +46,7 @@ export default async function createServer() {
 			maxDepthPlugin(),
 			maxDirectivesPlugin(),
 			maxTokensPlugin(),
-			useSentry(),
+			/* useSentry(), */
 		],
 		schema: createSchema<FastifyContext>({
 			resolvers,
@@ -87,15 +85,7 @@ export default async function createServer() {
 	});
 
 	app.get("/v5/feature-flags", async (request, reply) => {
-		const disabledFlags = process.env.DISABLED_FEATURE_FLAGS?.split(",") ?? [];
-		const flags = Object.fromEntries(disabledFlags.map(flag => [flag, false]));
-
-		const test = defu(flags, {
-			WebSocketManager: true,
-			SessionKeepAlive: true,
-		});
-
-		void reply.send(test);
+		void reply.send(featureFlags);
 	});
 
 	app.post("/v5/session-keep-alive", sessionKeepAlive);

apps/api-worker/src/graphql/resolvers/v5/Mutation/addScience.ts

@@ -1,4 +1,5 @@
 import { type } from "arktype";
+import { GraphQLError } from "graphql";
 import { redis } from "../../../../functions/createServer.js";
 import type { MutationResolvers } from "../../../../generated/graphql-v5.js";
 
@@ -15,7 +16,7 @@ const mutation: MutationResolvers["addScience"] = async (_parent, input) => {
 	const out = addScienceSchema(input);
 
 	if (out instanceof type.errors)
-		throw new Error(out.summary);
+		throw new GraphQLError(out.summary);
 
 	await redis.hset(
 		"pmd-api.scienceUpdates",

apps/api-worker/src/graphql/resolvers/v5/Mutation/heartbeat.ts

@@ -1,15 +1,17 @@
 import { type } from "arktype";
+import { GraphQLError } from "graphql";
 import type { MutationResolvers } from "../../../../generated/graphql-v5.js";
+import { redis } from "../../../../functions/createServer.js";
 
 const heartbeatSchema = type({
-	identifier: "string.uuid & string.lower",
-	presences: {
+	"identifier": "string.uuid & string.lower",
+	"presence?": {
 		service: "string.trim",
 		version: "string.semver",
 		language: "string.trim",
 		since: "number.epoch",
 	},
-	extension: {
+	"extension": {
 		"version": "string.semver",
 		"language": "string.trim",
 		"connected?": {
@@ -19,19 +21,29 @@ const heartbeatSchema = type({
 	},
 });
 
-const mutation: MutationResolvers["heartbeat"] = async (_parent, input) => {
+const mutation: MutationResolvers["heartbeat"] = async (_parent, input, context) => {
 	const out = heartbeatSchema(input);
 
 	if (out instanceof type.errors)
-		throw new Error(out.summary);
+		throw new GraphQLError(out.summary);
 
-	// ! Disabled for now
-	/* await redis.setex(
-		`pmd-api.heartbeatUpdates.${data.identifier}`,
-		// 5 minutes
-		300,
-		JSON.stringify(data)
-	); */
+	//* Get the user's IP address from Cloudflare headers or fallback to the request IP
+	const userIp = context.request.headers.get("cf-connecting-ip") || context.request.ip;
+
+	// * Use Redis Hash with 'service' in the key to store heartbeat data
+	const redisKey = `pmd-api.heartbeatUpdates.${out.identifier}`;
+	await redis.hset(redisKey, {
+		service: out.presence?.service,
+		version: out.presence?.version,
+		language: out.presence?.language,
+		since: out.presence?.since.toString(),
+		extension_version: out.extension.version,
+		extension_language: out.extension.language,
+		extension_connected_app: out.extension.connected?.app?.toString(),
+		extension_connected_discord: out.extension.connected?.discord?.toString(),
+		ip_address: userIp,
+	});
+	await redis.expire(redisKey, 300);
 
 	return {
 		__typename: "HeartbeatResult",

apps/api-worker/src/graphql/resolvers/v5/Mutation/index.ts

@@ -1,6 +1,6 @@
+import type { MutationResolvers } from "../../../../generated/graphql-v5.js";
 import addScience from "./addScience.js";
 import heartbeat from "./heartbeat.js";
-import type { MutationResolvers } from "../../../../generated/graphql-v5.js";
 
 export const Mutation: MutationResolvers = {
 	addScience,

apps/api-worker/src/graphql/resolvers/v5/Query/index.ts

@@ -1,5 +1,5 @@
-import presences from "./presences.js";
 import type { QueryResolvers } from "../../../../generated/graphql-v5.js";
+import presences from "./presences.js";
 
 export const Query: QueryResolvers = {
 	presences,

apps/api-worker/src/graphql/resolvers/v5/index.ts

@@ -1,6 +1,6 @@
+import type { Resolvers } from "../../../generated/graphql-v5.js";
 import { Mutation } from "./Mutation/index.js";
 import { Query } from "./Query/index.js";
-import type { Resolvers } from "../../../generated/graphql-v5.js";
 
 export const resolvers: Resolvers = {
 	Query,

apps/api-worker/src/index.ts

@@ -3,8 +3,6 @@ import process from "node:process";
 import * as Sentry from "@sentry/node";
 import { connect } from "mongoose";
 import "./tracing.js";
-
-// eslint-disable-next-line perfectionist/sort-imports
 import createServer from "./functions/createServer.js";
 
 // TODO SETUP SENTRY

apps/api-worker/src/routes/sessionKeepAlive.ts

@@ -4,17 +4,25 @@ import { type } from "arktype";
 import { Routes } from "discord-api-types/v10";
 import type { FastifyReply, FastifyRequest } from "fastify";
 import { redis } from "../functions/createServer.js";
+import { featureFlags } from "../constants.js";
 
 const schema = type({
 	token: "string.trim",
 	session: "string.trim",
+	version: "string.semver & string.trim",
+	scienceId: "string.trim",
 });
 
 export async function sessionKeepAlive(request: FastifyRequest, reply: FastifyReply) {
-	//* Get the 2 headers
+	if (!featureFlags.SessionKeepAlive)
+		return reply.status(202).send();
+
+	//* Get the headers
 	const out = schema({
 		token: request.headers["x-token"],
 		session: request.headers["x-session"],
+		version: request.headers["x-version"] ?? "2.6.8",
+		scienceId: request.headers["x-science-id"] ?? request.headers["x-token"],
 	});
 
 	if (out instanceof type.errors)
@@ -23,17 +31,15 @@ export async function sessionKeepAlive(request: FastifyRequest, reply: FastifyRe
 	if (!await isTokenValid(out.token))
 		return reply.status(400).send({ code: "INVALID_TOKEN", message: "The token is invalid" });
 
-	await redis.hset(
-		"pmd-api.sessions",
-		out.token,
-		JSON.stringify({
-			session: out.session,
-			token: out.token,
-			lastUpdated: Date.now(),
-		}),
-	);
+	const redisKey = `pmd-api.sessions.${out.scienceId}`;
+	await redis.hset(redisKey, {
+		session: out.session,
+		token: out.token,
+		lastUpdated: Date.now(),
+	});
+	await redis.expire(redisKey, 300); // 5 minutes
 
-	const interval = Number.parseInt(process.env.SESSION_KEEP_ALIVE_INTERVAL ?? "5000");
+	const interval = Number.parseInt(process.env.SESSION_KEEP_ALIVE_INTERVAL ?? "5000"); // 5 seconds
 
 	return reply.status(200).send({
 		code: "OK",

apps/pd/src/functions/createKeyv.ts

@@ -1,12 +1,11 @@
 import process from "node:process";
 import KeyvRedis from "@keyv/redis";
 import Keyv from "keyv";
-import type { KeyvOptions } from "keyv";
 
 import redis from "../redis.js";
 
 export default function createKeyv() {
-	let options: KeyvOptions | undefined;
+	let options: Keyv.Options<string> | undefined;
 
 	/* c8 ignore next 8 */
 	if (process.env.REDIS_SENTINELS) {
@@ -16,7 +15,7 @@ export default function createKeyv() {
 		};
 	}
 
-	const keyv = new Keyv(
+	const keyv = new Keyv<string>(
 		options,
 	);
 

apps/pd/src/routes/createFromImage.test.ts

@@ -1,9 +1,9 @@
 import { Buffer } from "node:buffer";
 import { readFile } from "node:fs/promises";
-import { afterAll, beforeAll, describe, it } from "vitest";
 
 import type { RequestOptions } from "node:http";
 import type { AddressInfo } from "node:net";
+import { afterAll, beforeAll, describe, it } from "vitest";
 
 import { createServer } from "../functions/createServer.js";
 

apps/pd/src/routes/createShortenedLink.ts

@@ -20,7 +20,7 @@ const handler: RouteHandlerMethod = async (request, reply) => {
 		return reply.status(400).send("Invalid URL");
 
 	const hash = crypto.createHash("sha256").update(url).digest("hex");
-	const existingShortenedUrl = await keyv.get<string>(hash);
+	const existingShortenedUrl = await keyv.get(hash);
 
 	void reply.header("Cache-control", "public, max-age=1800");
 

apps/pd/src/routes/getFullLink.ts

@@ -25,7 +25,7 @@ const handler: RouteHandlerMethod = async (request, reply) => {
 	if (id.split(".")[0]?.length !== 10)
 		return reply.code(404).send("Invalid ID");
 
-	const url = await keyv.get<string>(id);
+	const url = await keyv.get(id);
 	if (!url)
 		return reply.code(404).send("Unknown ID");
 

apps/website/server/api/getStaffData.ts

@@ -1,4 +1,4 @@
-import { ActivityType, flagsToBadges, PresenceUpdateStatus } from "@discord-user-card/vue";
+import { ActivityType, PresenceUpdateStatus, flagsToBadges } from "@discord-user-card/vue";
 import { REST } from "@discordjs/rest";
 import { Routes } from "discord-api-types/v10";
 import type { DiscordUserCardActivity, DiscordUserCardUser } from "@discord-user-card/vue";

apps/website/stores/useExtension.ts

@@ -22,7 +22,6 @@ export const useExtensionStore = defineStore("extension", () => {
 		}
 	}
 
-	// eslint-disable-next-line unicorn/consistent-function-scoping
 	function fetchPresences() {
 		window.dispatchEvent(new CustomEvent("PreMiD_GetPresenceList"));
 	}

package.json

@@ -38,5 +38,10 @@
 		"prettier": "^3.2.5",
 		"typescript": "^5.5.4",
 		"vitest": "^2.0.2"
+	},
+	"pnpm": {
+		"patchedDependencies": {
+			"ip-location-api@1.0.0": "patches/ip-location-api@1.0.0.patch"
+		}
 	}
 }

patches/ip-location-api@1.0.0.patch

@@ -0,0 +1,62 @@
+diff --git a/browser/country/README.md b/browser/country/README.md
+deleted file mode 100644
+index ac8fc934b4998f2a2cb7a92bf68bbdadd9e3d36d..0000000000000000000000000000000000000000
+diff --git a/browser/country-extra/README.md b/browser/country-extra/README.md
+deleted file mode 100644
+index 71e7237722915b2697b56ccb14171524eb4b40fb..0000000000000000000000000000000000000000
+diff --git a/browser/geocode/README.md b/browser/geocode/README.md
+deleted file mode 100644
+index 9d9a2205061f332b363b82d7561a0e3829d5bf2c..0000000000000000000000000000000000000000
+diff --git a/browser/geocode-extra/README.md b/browser/geocode-extra/README.md
+deleted file mode 100644
+index 38e17eebdd8532d07b460fbe7f385f36625ece9d..0000000000000000000000000000000000000000
+diff --git a/src/db.mjs b/src/db.mjs
+index 378b8a22084f860cc89720d1783a235c034717b2..cbffe1eaa84a94df536059d4b4af3f8f5ceb0ca7 100644
+--- a/src/db.mjs
++++ b/src/db.mjs
+@@ -33,7 +33,12 @@ export const update = async () => {
+ 	if(refreshTmpDir || !fsSync.existsSync(setting.tmpDataDir)){
+ 		// refresh tmp folder
+ 		await rimraf(setting.tmpDataDir)
+-		await fs.mkdir(setting.tmpDataDir)
++		await fs.mkdir(setting.tmpDataDir, {recursive: true})
++	}
++
++	// When specifying a custom dataDir, it doesn't always exists
++	if (!fsSync.existsSync(setting.dataDir)){
++		await fs.mkdir(setting.dataDir, {recursive: true})
+ 	}
+ 
+ 	console.log('Downloading database')
+diff --git a/src/main.mjs b/src/main.mjs
+index d001aca60902bc7fe41271c6fa7a0b6648607b15..5b2c125d8e7590afee82c794bf771accd656b2b7 100644
+--- a/src/main.mjs
++++ b/src/main.mjs
+@@ -3,7 +3,7 @@ import fs from 'fs/promises'
+ import fsSync from 'fs'
+ import path from 'path'
+ import { exec } from 'child_process'
+-
++import { fileURLToPath } from "url"
+ import { countries, continents } from 'countries-list'
+ 
+ import { setting, setSetting, getSettingCmd } from './setting.mjs'
+@@ -14,6 +14,9 @@ const v6db = setting.v6
+ const locFieldHash = setting.locFieldHash
+ const mainFieldHash = setting.mainFieldHash
+ 
++const __filename = fileURLToPath(import.meta.url)
++const __dirname = path.dirname(__filename)
++
+ //---------------------------------------
+ // Database lookup
+ //---------------------------------------
+@@ -235,7 +238,7 @@ export const updateDb = (_setting) => {
+ 	// However, db.js import many external modules, it makes slow down the startup time and uses more memory.
+ 	// Therefore, we use exec() to run the script in the other process.
+ 	return new Promise((resolve, reject) => {
+-		var cmd = 'node ' + path.resolve(__dirname, '..', 'script', 'updatedb.js')
++		var cmd = 'node ' + path.resolve(__dirname, '..', 'script', 'updatedb.mjs')
+ 		var arg
+ 		if(_setting){
+ 			var oldSetting = Object.assign({}, setting)

tsconfig.base.json

@@ -29,5 +29,5 @@
 		"isolatedModules": true,
 		"skipLibCheck": true
 	},
-	"exclude": ["**/*/node_modules", "**/*/dist"]
+	"exclude": ["**/*/node_modules", "**/*/dist", "**/drizzle.config.ts"]
 }