commit 662896ee2b7f88a6b8423390cb06d998ae71e2a8 · dunkirk.sh/cachet

+24 -24

package.json

···

       1
        
       {

     

       2
       -
         "name": "cachet",

     

       3
       -
         "version": "0.3.2",

     

       4
       -
         "scripts": {

     

       5
       -
           "test": "echo \"Error: no test specified\" && exit 1",

     

       6
       -
           "dev": "bun run --watch src/index.ts",

     

       7
       -
           "start": "bun run src/index.ts",

     

       8
       -
           "build": "bun build --compile --outfile dist/cachet --production ./src/index.ts"

     

       9
       -
         },

     

       10
       -
         "dependencies": {

     

       11
       -
           "@sentry/bun": "^9.40.0",

     

       12
       -
           "@tqman/nice-logger": "^1.0.7",

     

       13
       -
           "@types/node-cron": "^3.0.11",

     

       14
       -
           "bottleneck": "^2.19.5",

     

       15
       -
           "elysia": "1.1.26",

     

       16
       -
           "node-cron": "^3.0.3",

     

       17
       -
           "sentry": "^0.1.2"

     

       18
       -
         },

     

       19
       -
         "devDependencies": {

     

       20
       -
           "@types/bun": "latest"

     

       21
       -
         },

     

       22
       -
         "private": true,

     

       23
       -
         "peerDependencies": {

     

       24
       -
           "typescript": "^5"

     

       25
       -
         }

     

       26
        
       }

···

       1
        
       {

     

       2
       +
       	"name": "cachet",

     

       3
       +
       	"version": "0.3.2",

     

       4
       +
       	"scripts": {

     

       5
       +
       		"test": "echo \"Error: no test specified\" && exit 1",

     

       6
       +
       		"dev": "bun run --watch src/index.ts",

     

       7
       +
       		"start": "bun run src/index.ts",

     

       8
       +
       		"build": "bun build --compile --outfile dist/cachet --production ./src/index.ts"

     

       9
       +
       	},

     

       10
       +
       	"dependencies": {

     

       11
       +
       		"@sentry/bun": "^9.40.0",

     

       12
       +
       		"@tqman/nice-logger": "^1.0.7",

     

       13
       +
       		"@types/node-cron": "^3.0.11",

     

       14
       +
       		"bottleneck": "^2.19.5",

     

       15
       +
       		"elysia": "1.1.26",

     

       16
       +
       		"node-cron": "^3.0.3",

     

       17
       +
       		"sentry": "^0.1.2"

     

       18
       +
       	},

     

       19
       +
       	"devDependencies": {

     

       20
       +
       		"@types/bun": "latest"

     

       21
       +
       	},

     

       22
       +
       	"private": true,

     

       23
       +
       	"peerDependencies": {

     

       24
       +
       		"typescript": "^5"

     

       25
       +
       	}

     

       26
        
       }

+53 -28

src/cache.ts

···

       125
        
       /**

     

       126
        
        * Discriminated union for all analytics cache data types

     

       127
        
        */

     

       128
       -
       type AnalyticsCacheData = 

     

       129
       -
       	| { type: 'analytics'; data: FullAnalyticsData }

     

       130
       -
       	| { type: 'essential'; data: EssentialStatsData }

     

       131
       -
       	| { type: 'charts'; data: ChartData }

     

       132
       -
       	| { type: 'useragents'; data: UserAgentData };

     

       133
        
       

     

       134
        
       /**

     

       135
        
        * Type-safe analytics cache entry

     
···

       142
        
       /**

     

       143
        
        * Type guard functions for cache data

     

       144
        
        */

     

       145
       -
       function isAnalyticsData(data: AnalyticsCacheData): data is { type: 'analytics'; data: FullAnalyticsData } {

     

       146
       -
       	return data.type === 'analytics';

     

       0
        
       
     

       0
        
       
     

       147
        
       }

     

       148
        
       

     

       149
       -
       function isEssentialStatsData(data: AnalyticsCacheData): data is { type: 'essential'; data: EssentialStatsData } {

     

       150
       -
       	return data.type === 'essential';

     

       0
        
       
     

       0
        
       
     

       151
        
       }

     

       152
        
       

     

       153
       -
       function isChartData(data: AnalyticsCacheData): data is { type: 'charts'; data: ChartData } {

     

       154
       -
       	return data.type === 'charts';

     

       0
        
       
     

       0
        
       
     

       155
        
       }

     

       156
        
       

     

       157
       -
       function isUserAgentData(data: AnalyticsCacheData): data is { type: 'useragents'; data: UserAgentData } {

     

       158
       -
       	return data.type === 'useragents';

     

       0
        
       
     

       0
        
       
     

       159
        
       }

     

       160
        
       

     

       161
        
       /**

     
···

       178
        
       	getAnalyticsData(key: string): FullAnalyticsData | null {

     

       179
        
       		const cached = this.cache.get(key);

     

       180
        
       		const now = Date.now();

     

       181
       -
       		

     

       182
       -
       		if (cached && now - cached.timestamp < this.cacheTTL && isAnalyticsData(cached.data)) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       183
        
       			return cached.data.data;

     

       184
        
       		}

     

       185
        
       		return null;

     
···

       191
        
       	getEssentialStatsData(key: string): EssentialStatsData | null {

     

       192
        
       		const cached = this.cache.get(key);

     

       193
        
       		const now = Date.now();

     

       194
       -
       		

     

       195
       -
       		if (cached && now - cached.timestamp < this.cacheTTL && isEssentialStatsData(cached.data)) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       196
        
       			return cached.data.data;

     

       197
        
       		}

     

       198
        
       		return null;

     
···

       204
        
       	getChartData(key: string): ChartData | null {

     

       205
        
       		const cached = this.cache.get(key);

     

       206
        
       		const now = Date.now();

     

       207
       -
       		

     

       208
       -
       		if (cached && now - cached.timestamp < this.cacheTTL && isChartData(cached.data)) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       209
        
       			return cached.data.data;

     

       210
        
       		}

     

       211
        
       		return null;

     
···

       217
        
       	getUserAgentData(key: string): UserAgentData | null {

     

       218
        
       		const cached = this.cache.get(key);

     

       219
        
       		const now = Date.now();

     

       220
       -
       		

     

       221
       -
       		if (cached && now - cached.timestamp < this.cacheTTL && isUserAgentData(cached.data)) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       222
        
       			return cached.data.data;

     

       223
        
       		}

     

       224
        
       		return null;

     
···

       228
        
       	 * Set analytics data in cache with type safety

     

       229
        
       	 */

     

       230
        
       	setAnalyticsData(key: string, data: FullAnalyticsData): void {

     

       231
       -
       		this.setCacheEntry(key, { type: 'analytics', data });

     

       232
        
       	}

     

       233
        
       

     

       234
        
       	/**

     

       235
        
       	 * Set essential stats data in cache with type safety

     

       236
        
       	 */

     

       237
        
       	setEssentialStatsData(key: string, data: EssentialStatsData): void {

     

       238
       -
       		this.setCacheEntry(key, { type: 'essential', data });

     

       239
        
       	}

     

       240
        
       

     

       241
        
       	/**

     

       242
        
       	 * Set chart data in cache with type safety

     

       243
        
       	 */

     

       244
        
       	setChartData(key: string, data: ChartData): void {

     

       245
       -
       		this.setCacheEntry(key, { type: 'charts', data });

     

       246
        
       	}

     

       247
        
       

     

       248
        
       	/**

     

       249
        
       	 * Set user agent data in cache with type safety

     

       250
        
       	 */

     

       251
        
       	setUserAgentData(key: string, data: UserAgentData): void {

     

       252
       -
       		this.setCacheEntry(key, { type: 'useragents', data });

     

       253
        
       	}

     

       254
        
       

     

       255
        
       	/**

     
···

       657
        
       		// Check memory usage

     

       658
        
       		const memUsage = process.memoryUsage();

     

       659
        
       		const bytesToMiB = (bytes: number) => bytes / 1024 / 1024;

     

       660
       -
       		

     

       661
        
       		const heapUsedMiB = bytesToMiB(memUsage.heapUsed);

     

       662
        
       		const heapTotalMiB = bytesToMiB(memUsage.heapTotal);

     

       663
       -
       		const heapPercent = heapTotalMiB > 0 ? (heapUsedMiB / heapTotalMiB) * 100 : 0;

     

       0
        
       
     

       664
        
       		const rssMiB = bytesToMiB(memUsage.rss);

     

       665
        
       		const externalMiB = bytesToMiB(memUsage.external || 0);

     

       666
        
       		const arrayBuffersMiB = bytesToMiB(memUsage.arrayBuffers || 0);

     

       667
       -
       		

     

       668
        
       		checks.memoryUsage = {

     

       669
        
       			heapUsed: Math.round(heapUsedMiB),

     

       670
        
       			heapTotal: Math.round(heapTotalMiB),

···

       125
        
       /**

     

       126
        
        * Discriminated union for all analytics cache data types

     

       127
        
        */

     

       128
       +
       type AnalyticsCacheData =

     

       129
       +
       	| { type: "analytics"; data: FullAnalyticsData }

     

       130
       +
       	| { type: "essential"; data: EssentialStatsData }

     

       131
       +
       	| { type: "charts"; data: ChartData }

     

       132
       +
       	| { type: "useragents"; data: UserAgentData };

     

       133
        
       

     

       134
        
       /**

     

       135
        
        * Type-safe analytics cache entry

     
···

       142
        
       /**

     

       143
        
        * Type guard functions for cache data

     

       144
        
        */

     

       145
       +
       function isAnalyticsData(

     

       146
       +
       	data: AnalyticsCacheData,

     

       147
       +
       ): data is { type: "analytics"; data: FullAnalyticsData } {

     

       148
       +
       	return data.type === "analytics";

     

       149
        
       }

     

       150
        
       

     

       151
       +
       function isEssentialStatsData(

     

       152
       +
       	data: AnalyticsCacheData,

     

       153
       +
       ): data is { type: "essential"; data: EssentialStatsData } {

     

       154
       +
       	return data.type === "essential";

     

       155
        
       }

     

       156
        
       

     

       157
       +
       function isChartData(

     

       158
       +
       	data: AnalyticsCacheData,

     

       159
       +
       ): data is { type: "charts"; data: ChartData } {

     

       160
       +
       	return data.type === "charts";

     

       161
        
       }

     

       162
        
       

     

       163
       +
       function isUserAgentData(

     

       164
       +
       	data: AnalyticsCacheData,

     

       165
       +
       ): data is { type: "useragents"; data: UserAgentData } {

     

       166
       +
       	return data.type === "useragents";

     

       167
        
       }

     

       168
        
       

     

       169
        
       /**

     
···

       186
        
       	getAnalyticsData(key: string): FullAnalyticsData | null {

     

       187
        
       		const cached = this.cache.get(key);

     

       188
        
       		const now = Date.now();

     

       189
       +
       

     

       190
       +
       		if (

     

       191
       +
       			cached &&

     

       192
       +
       			now - cached.timestamp < this.cacheTTL &&

     

       193
       +
       			isAnalyticsData(cached.data)

     

       194
       +
       		) {

     

       195
        
       			return cached.data.data;

     

       196
        
       		}

     

       197
        
       		return null;

     
···

       203
        
       	getEssentialStatsData(key: string): EssentialStatsData | null {

     

       204
        
       		const cached = this.cache.get(key);

     

       205
        
       		const now = Date.now();

     

       206
       +
       

     

       207
       +
       		if (

     

       208
       +
       			cached &&

     

       209
       +
       			now - cached.timestamp < this.cacheTTL &&

     

       210
       +
       			isEssentialStatsData(cached.data)

     

       211
       +
       		) {

     

       212
        
       			return cached.data.data;

     

       213
        
       		}

     

       214
        
       		return null;

     
···

       220
        
       	getChartData(key: string): ChartData | null {

     

       221
        
       		const cached = this.cache.get(key);

     

       222
        
       		const now = Date.now();

     

       223
       +
       

     

       224
       +
       		if (

     

       225
       +
       			cached &&

     

       226
       +
       			now - cached.timestamp < this.cacheTTL &&

     

       227
       +
       			isChartData(cached.data)

     

       228
       +
       		) {

     

       229
        
       			return cached.data.data;

     

       230
        
       		}

     

       231
        
       		return null;

     
···

       237
        
       	getUserAgentData(key: string): UserAgentData | null {

     

       238
        
       		const cached = this.cache.get(key);

     

       239
        
       		const now = Date.now();

     

       240
       +
       

     

       241
       +
       		if (

     

       242
       +
       			cached &&

     

       243
       +
       			now - cached.timestamp < this.cacheTTL &&

     

       244
       +
       			isUserAgentData(cached.data)

     

       245
       +
       		) {

     

       246
        
       			return cached.data.data;

     

       247
        
       		}

     

       248
        
       		return null;

     
···

       252
        
       	 * Set analytics data in cache with type safety

     

       253
        
       	 */

     

       254
        
       	setAnalyticsData(key: string, data: FullAnalyticsData): void {

     

       255
       +
       		this.setCacheEntry(key, { type: "analytics", data });

     

       256
        
       	}

     

       257
        
       

     

       258
        
       	/**

     

       259
        
       	 * Set essential stats data in cache with type safety

     

       260
        
       	 */

     

       261
        
       	setEssentialStatsData(key: string, data: EssentialStatsData): void {

     

       262
       +
       		this.setCacheEntry(key, { type: "essential", data });

     

       263
        
       	}

     

       264
        
       

     

       265
        
       	/**

     

       266
        
       	 * Set chart data in cache with type safety

     

       267
        
       	 */

     

       268
        
       	setChartData(key: string, data: ChartData): void {

     

       269
       +
       		this.setCacheEntry(key, { type: "charts", data });

     

       270
        
       	}

     

       271
        
       

     

       272
        
       	/**

     

       273
        
       	 * Set user agent data in cache with type safety

     

       274
        
       	 */

     

       275
        
       	setUserAgentData(key: string, data: UserAgentData): void {

     

       276
       +
       		this.setCacheEntry(key, { type: "useragents", data });

     

       277
        
       	}

     

       278
        
       

     

       279
        
       	/**

     
···

       681
        
       		// Check memory usage

     

       682
        
       		const memUsage = process.memoryUsage();

     

       683
        
       		const bytesToMiB = (bytes: number) => bytes / 1024 / 1024;

     

       684
       +
       

     

       685
        
       		const heapUsedMiB = bytesToMiB(memUsage.heapUsed);

     

       686
        
       		const heapTotalMiB = bytesToMiB(memUsage.heapTotal);

     

       687
       +
       		const heapPercent =

     

       688
       +
       			heapTotalMiB > 0 ? (heapUsedMiB / heapTotalMiB) * 100 : 0;

     

       689
        
       		const rssMiB = bytesToMiB(memUsage.rss);

     

       690
        
       		const externalMiB = bytesToMiB(memUsage.external || 0);

     

       691
        
       		const arrayBuffersMiB = bytesToMiB(memUsage.arrayBuffers || 0);

     

       692
       +
       

     

       693
        
       		checks.memoryUsage = {

     

       694
        
       			heapUsed: Math.round(heapUsedMiB),

     

       695
        
       			heapTotal: Math.round(heapTotalMiB),

+6 -1

src/handlers/index.ts

···

       29
        
       

     

       30
        
       	if (detailed) {

     

       31
        
       		const health = await cache.detailedHealthCheck();

     

       32
       -
       		const statusCode = health.status === "unhealthy" ? 503 : health.status === "degraded" ? 200 : 200;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       33
        
       		await recordAnalytics(statusCode);

     

       34
        
       		return Response.json(health, { status: statusCode });

     

       35
        
       	}

···

       29
        
       

     

       30
        
       	if (detailed) {

     

       31
        
       		const health = await cache.detailedHealthCheck();

     

       32
       +
       		const statusCode =

     

       33
       +
       			health.status === "unhealthy"

     

       34
       +
       				? 503

     

       35
       +
       				: health.status === "degraded"

     

       36
       +
       					? 200

     

       37
       +
       					: 200;

     

       38
        
       		await recordAnalytics(statusCode);

     

       39
        
       		return Response.json(health, { status: statusCode });

     

       40
        
       	}

+24 -6

src/routes/api-routes.ts

···

       82
        
       												details: {

     

       83
        
       													type: "object",

     

       84
        
       													properties: {

     

       85
       -
       														heapUsedMiB: { type: "number", description: "Precise heap used in MiB" },

     

       86
       -
       														heapTotalMiB: { type: "number", description: "Precise heap total in MiB" },

     

       87
       -
       														heapPercent: { type: "number", description: "Precise heap percentage" },

     

       88
       -
       														rssMiB: { type: "number", description: "Resident Set Size in MiB" },

     

       89
       -
       														externalMiB: { type: "number", description: "External memory in MiB" },

     

       90
       -
       														arrayBuffersMiB: { type: "number", description: "Array buffers in MiB" },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       91
        
       													},

     

       92
        
       												},

     

       93
        
       											},

···

       82
        
       												details: {

     

       83
        
       													type: "object",

     

       84
        
       													properties: {

     

       85
       +
       														heapUsedMiB: {

     

       86
       +
       															type: "number",

     

       87
       +
       															description: "Precise heap used in MiB",

     

       88
       +
       														},

     

       89
       +
       														heapTotalMiB: {

     

       90
       +
       															type: "number",

     

       91
       +
       															description: "Precise heap total in MiB",

     

       92
       +
       														},

     

       93
       +
       														heapPercent: {

     

       94
       +
       															type: "number",

     

       95
       +
       															description: "Precise heap percentage",

     

       96
       +
       														},

     

       97
       +
       														rssMiB: {

     

       98
       +
       															type: "number",

     

       99
       +
       															description: "Resident Set Size in MiB",

     

       100
       +
       														},

     

       101
       +
       														externalMiB: {

     

       102
       +
       															type: "number",

     

       103
       +
       															description: "External memory in MiB",

     

       104
       +
       														},

     

       105
       +
       														arrayBuffersMiB: {

     

       106
       +
       															type: "number",

     

       107
       +
       															description: "Array buffers in MiB",

     

       108
       +
       														},

     

       109
        
       													},

     

       110
        
       												},

     

       111
        
       											},