api-health-middleware 1.0.2 → 1.0.4

package/README.md

@@ -1,135 +1,102 @@
-# API-Monitor-Middleware
+````markdown
+# api-health-middleware
 
-[![npm version](https://img.shields.io/npm/v/api-health-middleware)](https://www.npmjs.com/package/api-health-middleware)
-[![License](https://img.shields.io/npm/l/api-health-middleware)](LICENSE)
-[![Downloads](https://img.shields.io/npm/dt/api-health-middleware)](https://www.npmjs.com/package/api-health-middleware)
+**Express middleware to report per-request API health to a monitoring backend.**
 
-A lightweight **Express middleware** to automatically monitor API health.  
-It tracks requests, responses, errors, response time, and uptime, sending logs to your dashboard (Under Development) using an API key.
-
-This package is plug-and-play — just install it, provide your API key, and it works out-of-the-box.
+This middleware logs API requests, response times, and status codes to a remote health endpoint. Designed to be lightweight and non-blocking, it works with any Express.js application.
 
 ---
 
-## Features
+## Installation
 
-- Automatic logging of all API requests
-- Tracks:
-  - Endpoint (`/api/users`, `/login`, etc.)
-  - HTTP method (GET, POST, PUT, DELETE)
-  - Status code (200, 404, 500, etc.)
-  - Response time in milliseconds
-  - Success / error messages
-  - IP address and User-Agent
-- Works with Express 4.x and above
+```bash
+# From npm
+npm install api-health-middleware
 
----
+# Or locally via file
+npm install /path/to/api-health-middleware
+````
 
-## Installation
+---
 
-```bash
-npm i api-health-middleware
+## Usage
 
-Usage
-1. Import and Initialize Middleware
+```js
 const express = require('express');
-const app = express();
-
-// Import health monitor middleware
 const healthMonitor = require('api-health-middleware');
 
-// Use middleware globally
+const app = express();
+
+// Initialize middleware with your API key
 app.use(
   healthMonitor({
-    apiKey: 'YOUR_DASHBOARD_API_KEY', // Required
+    apiKey: "YOUR_API_KEY"
   })
 );
 
-app.get('/api/users', (req, res) => {
-  res.json({ message: 'Hello users' });
+app.get('/hello', (req, res) => {
+  res.send('Hello World!');
 });
 
-app.listen(3000, () => console.log('Server running on port 3000'));
-
-2. How It Works
-
-Middleware intercepts every request and response.
-
-Captures metrics: endpoint, method, status, response time, IP, User-Agent.
-
-Sends logs asynchronously to your monitoring dashboard using the API key.
-
-Your dashboard aggregates metrics per project, showing:
-
-Total API calls
-
-Error count
-
-Average response time
-
-Uptime percentage
-
-3. Middleware Configuration Options
-Option	Type	Required	Default	Description
-apiKey	string	✅ Yes	—	API key generated from your dashboard for authentication
-Example Log Object Sent to Dashboard
-{
-  "timestamp": "2026-02-11T16:24:00.123Z",
-  "method": "GET",
-  "endpoint": "/users",
-  "statusCode": 200,
-  "responseTimeMs": 123,
-  "success": true,
-  "errorMessage": null,
-  "ip": "192.168.0.1",
-  "userAgent": "PostmanRuntime/7.28.4",
-  "projectId": "623d2f6b9e1b0a0012345678"
-}
-
-Example Metrics from Dashboard
-
-Total API calls: 120
-
-Error count: 5
-
-Average response time: 135 ms
+app.listen(3000, () => {
+  console.log('Server running on port 3000');
+});
+```
 
-Uptime: 95.83%
+---
 
-Best Practices
+## Configuration Options
 
-Async logging – middleware sends logs asynchronously to avoid blocking API responses.
+| Option | Type   | Description                        | Required |
+| ------ | ------ | ---------------------------------- | -------- |
+| apiKey | string | Your API key for the health server | Yes      |
 
+---
 
-Use environments – differentiate production, staging, or development metrics.
+## How It Works
 
-Batch logs – optionally batch logs to reduce network calls.
+* Measures request duration using `process.hrtime.bigint()`.
+* Captures:
 
-Secure API key – never commit it publicly.
+  * HTTP method
+  * Endpoint URL
+  * Status code
+  * Response time in milliseconds
+  * IP and User-Agent
+* Automatically ignores logging requests sent to `/logs/health` to prevent recursion.
+* Non-blocking and fails silently if the health server is unreachable.
 
-Contributing
+---
 
-We welcome contributions!
+## Notes
 
-Fork the repo
+* Requires Node.js **18+** for native `fetch`.
+  For Node < 18, install `node-fetch` and import it:
 
-Create a new branch (feature/my-feature)
+```js
+const fetch = require('node-fetch');
+```
 
-Run tests:
+* Compatible with Express.js v4+.
 
-npm test
+---
 
+## Development
 
-Submit a pull request
+Clone the repository and link locally:
 
-License
+```bash
+cd api-health-middleware
+npm link
 
-MIT © Your Name
+# In your app project
+npm link api-health-middleware
+```
 
-Acknowledgements
+---
 
-Inspired by Postman Monitors and lightweight API monitoring systems.
+## License
 
+MIT © Tarun Thakur
 
----
 

package/package.json

@@ -1,23 +1,21 @@
 {
   "name": "api-health-middleware",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Express middleware to report per-request API health to a monitoring backend",
   "main": "src/index.js",
   "scripts": {
-    "start" : "node index.js"
+    "start": "node index.js"
   },
-  "keywords": ["api", "health", "monitoring", "express", "middleware"],
+  "keywords": [
+    "api",
+    "health",
+    "monitoring",
+    "express",
+    "middleware"
+  ],
   "author": "Tarun Thakur",
   "license": "MIT",
-  "type": "module",
-  "dependencies": {
-    "axios": "^1.13.4"
-  },
   "peerDependencies": {
     "express": ">=4"
   }
-
 }
-
-
-

package/src/index.js

@@ -1 +1,3 @@
-export { apiHealth } from "./middleware.js";
+const apiHealth = require("./middleware");
+
+module.exports = apiHealth;

package/src/middleware.js

@@ -1,8 +1,6 @@
-import axios from "axios";
+const INGEST_ENDPOINT = "https://devops-lite-backend.onrender.com";
 
-const INGEST_ENDPOINT = "http://localhost:5000/logs/health";
-
-export function apiHealth({ apiKey }) {
+function apiHealth({ apiKey }) {
   if (!apiKey) throw new Error("apiKey is required");
 
   return function apiHealthMiddleware(req, res, next) {
@@ -18,7 +16,7 @@ export function apiHealth({ apiKey }) {
 
         const payload = {
           timestamp: new Date().toISOString(),
-          Method: req.method,
+          method: req.method,
           endpoint: req.route?.path || req.originalUrl,
           fullUrl: req.originalUrl,
           statusCode: res.statusCode,
@@ -32,18 +30,23 @@ export function apiHealth({ apiKey }) {
           userAgent: req.headers["user-agent"] || null,
         };
 
-        // Fire and forget (do not await)
-        axios.post(INGEST_ENDPOINT, payload, {
+        // Timeout handling using AbortController
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 2000);
+
+        fetch(INGEST_ENDPOINT, {
+          method: "POST",
           headers: {
             "x-api-key": apiKey,
             "Content-Type": "application/json",
           },
-          timeout: 2000,
-        }).catch(() => {
-          // silently fail (monitoring should never break main API)
-        });
+          body: JSON.stringify(payload),
+          signal: controller.signal,
+        })
+          .catch(() => {}) // Silent fail
+          .finally(() => clearTimeout(timeout));
 
-      } catch (err) {
+      } catch {
         // Never break main request
       }
     });
@@ -51,3 +54,5 @@ export function apiHealth({ apiKey }) {
     next();
   };
 }
+
+module.exports = apiHealth;