pms_md 1.0.0

package/node-monitor/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@projectmd/node-monitor",
+  "version": "1.0.0",
+  "description": "Comprehensive monitoring solution for Node.js applications with error tracking, health checks, and multi-channel notifications",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "jest",
+    "start": "node examples/express-app.js",
+    "prepublishOnly": "echo 'Running pre-publish checks...'",
+    "version": "echo 'Version updated'"
+  },
+  "keywords": [
+    "monitoring",
+    "health-check",
+    "error-tracking",
+    "notifications",
+    "alerts",
+    "nodejs",
+    "express",
+    "logging",
+    "winston",
+    "error-handler",
+    "health-monitoring",
+    "system-monitoring",
+    "email-notifications",
+    "slack-notifications"
+  ],
+  "author": "ProjectMD",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/projectmd/node-monitor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/projectmd/node-monitor/issues"
+  },
+  "homepage": "https://github.com/projectmd/node-monitor#readme",
+  "dependencies": {
+    "winston": "^3.11.0",
+    "winston-daily-rotate-file": "^4.7.1",
+    "nodemailer": "^6.9.7",
+    "@slack/webhook": "^7.0.2",
+    "axios": "^1.6.2",
+    "node-cron": "^3.0.3"
+  },
+  "peerDependencies": {
+    "express": "^4.18.0 || ^5.0.0",
+    "mongoose": "^7.0.0 || ^8.0.0",
+    "pg": "^8.11.0",
+    "mysql2": "^3.6.0",
+    "ioredis": "^5.3.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "mongoose": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/node-monitor/pre-publish-check.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-publish validation script
+ * Run this before publishing to npm to ensure everything is ready
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('🔍 Running pre-publish checks...\n');
+
+let hasErrors = false;
+let hasWarnings = false;
+
+// Check 1: package.json exists and is valid
+console.log('📦 Checking package.json...');
+try {
+  const pkg = require('./package.json');
+  
+  if (!pkg.name) {
+    console.error('  ❌ package.json missing "name" field');
+    hasErrors = true;
+  } else {
+    console.log(`  ✅ Package name: ${pkg.name}`);
+  }
+  
+  if (!pkg.version) {
+    console.error('  ❌ package.json missing "version" field');
+    hasErrors = true;
+  } else {
+    console.log(`  ✅ Version: ${pkg.version}`);
+  }
+  
+  if (!pkg.description) {
+    console.warn('  ⚠️  package.json missing "description" field');
+    hasWarnings = true;
+  } else {
+    console.log(`  ✅ Description: ${pkg.description.substring(0, 50)}...`);
+  }
+  
+  if (!pkg.main) {
+    console.error('  ❌ package.json missing "main" field');
+    hasErrors = true;
+  } else {
+    console.log(`  ✅ Main entry point: ${pkg.main}`);
+  }
+  
+  if (!pkg.repository) {
+    console.warn('  ⚠️  package.json missing "repository" field');
+    hasWarnings = true;
+  } else {
+    console.log(`  ✅ Repository: ${pkg.repository.url}`);
+  }
+  
+  if (!pkg.license) {
+    console.warn('  ⚠️  package.json missing "license" field');
+    hasWarnings = true;
+  } else {
+    console.log(`  ✅ License: ${pkg.license}`);
+  }
+  
+  if (!pkg.keywords || pkg.keywords.length === 0) {
+    console.warn('  ⚠️  package.json has no keywords (helps with discoverability)');
+    hasWarnings = true;
+  } else {
+    console.log(`  ✅ Keywords: ${pkg.keywords.length} keywords defined`);
+  }
+  
+} catch (error) {
+  console.error('  ❌ Error reading package.json:', error.message);
+  hasErrors = true;
+}
+
+console.log('');
+
+// Check 2: Main entry point exists
+console.log('📄 Checking main entry point...');
+const mainFile = path.join(__dirname, 'src/index.js');
+if (fs.existsSync(mainFile)) {
+  console.log('  ✅ src/index.js exists');
+} else {
+  console.error('  ❌ src/index.js not found');
+  hasErrors = true;
+}
+
+console.log('');
+
+// Check 3: README exists
+console.log('📖 Checking README...');
+const readmeFile = path.join(__dirname, 'README.md');
+if (fs.existsSync(readmeFile)) {
+  const readmeContent = fs.readFileSync(readmeFile, 'utf8');
+  console.log('  ✅ README.md exists');
+  
+  if (readmeContent.length < 100) {
+    console.warn('  ⚠️  README.md seems very short');
+    hasWarnings = true;
+  } else {
+    console.log(`  ✅ README.md has ${readmeContent.length} characters`);
+  }
+} else {
+  console.error('  ❌ README.md not found');
+  hasErrors = true;
+}
+
+console.log('');
+
+// Check 4: LICENSE exists
+console.log('⚖️  Checking LICENSE...');
+const licenseFile = path.join(__dirname, 'LICENSE');
+if (fs.existsSync(licenseFile)) {
+  console.log('  ✅ LICENSE file exists');
+} else {
+  console.error('  ❌ LICENSE file not found');
+  hasErrors = true;
+}
+
+console.log('');
+
+// Check 5: .npmignore exists
+console.log('🚫 Checking .npmignore...');
+const npmignoreFile = path.join(__dirname, '.npmignore');
+if (fs.existsSync(npmignoreFile)) {
+  console.log('  ✅ .npmignore exists');
+} else {
+  console.warn('  ⚠️  .npmignore not found (will use .gitignore)');
+  hasWarnings = true;
+}
+
+console.log('');
+
+// Check 6: No .env files in root
+console.log('🔐 Checking for sensitive files...');
+const envFile = path.join(__dirname, '.env');
+if (fs.existsSync(envFile)) {
+  console.warn('  ⚠️  .env file found (make sure it\'s in .npmignore)');
+  hasWarnings = true;
+} else {
+  console.log('  ✅ No .env file in root');
+}
+
+console.log('');
+
+// Check 7: Source files exist
+console.log('📁 Checking source files...');
+const srcDir = path.join(__dirname, 'src');
+if (fs.existsSync(srcDir)) {
+  const srcFiles = fs.readdirSync(srcDir, { recursive: true });
+  const jsFiles = srcFiles.filter(f => f.endsWith('.js'));
+  console.log(`  ✅ src/ directory exists with ${jsFiles.length} JavaScript files`);
+} else {
+  console.error('  ❌ src/ directory not found');
+  hasErrors = true;
+}
+
+console.log('');
+
+// Check 8: node_modules size warning
+console.log('📦 Checking dependencies...');
+const nodeModulesDir = path.join(__dirname, 'node_modules');
+if (fs.existsSync(nodeModulesDir)) {
+  console.log('  ✅ Dependencies installed');
+  console.log('  ℹ️  Note: node_modules/ will be excluded from npm package');
+} else {
+  console.warn('  ⚠️  node_modules/ not found - run "npm install" first');
+  hasWarnings = true;
+}
+
+console.log('');
+
+// Summary
+console.log('═══════════════════════════════════════════════════════');
+if (hasErrors) {
+  console.log('❌ FAILED - Please fix the errors above before publishing');
+  process.exit(1);
+} else if (hasWarnings) {
+  console.log('⚠️  PASSED WITH WARNINGS - Review warnings above');
+  console.log('');
+  console.log('✅ You can proceed with publishing, but consider fixing warnings');
+  console.log('');
+  console.log('Next steps:');
+  console.log('  1. npm login');
+  console.log('  2. npm publish --dry-run --access public');
+  console.log('  3. npm publish --access public');
+  process.exit(0);
+} else {
+  console.log('✅ ALL CHECKS PASSED!');
+  console.log('');
+  console.log('Your package is ready to publish! 🚀');
+  console.log('');
+  console.log('Next steps:');
+  console.log('  1. npm login');
+  console.log('  2. npm publish --dry-run --access public  (test run)');
+  console.log('  3. npm publish --access public  (actual publish)');
+  console.log('');
+  console.log('See PUBLISHING_GUIDE.md for detailed instructions.');
+  process.exit(0);
+}
+

package/node-monitor/src/config/monitoringConfig.js

@@ -0,0 +1,255 @@
+/**
+ * Monitoring Configuration Manager
+ * Handles configuration with environment variable support and validation
+ */
+
+class MonitoringConfig {
+  constructor(userConfig = {}) {
+    this.config = this.mergeWithDefaults(userConfig);
+    this.validateConfig();
+  }
+
+  /**
+   * Default configuration values
+   */
+  getDefaults() {
+    return {
+      // Monitoring intervals (in milliseconds)
+      intervals: {
+        health: parseInt(process.env.MONITOR_HEALTH_INTERVAL) || 60000,      // 1 minute
+        system: parseInt(process.env.MONITOR_SYSTEM_INTERVAL) || 300000,     // 5 minutes
+        database: parseInt(process.env.MONITOR_DATABASE_INTERVAL) || 120000  // 2 minutes
+      },
+
+      // Alert thresholds
+      thresholds: {
+        cpu: parseInt(process.env.MONITOR_CPU_THRESHOLD) || 80,              // percentage
+        memory: parseInt(process.env.MONITOR_MEMORY_THRESHOLD) || 90,        // percentage
+        errorRate: parseInt(process.env.MONITOR_ERROR_RATE_THRESHOLD) || 50, // errors per minute
+        responseTime: parseInt(process.env.MONITOR_RESPONSE_TIME_THRESHOLD) || 5000, // milliseconds
+        consecutiveFailures: parseInt(process.env.MONITOR_CONSECUTIVE_FAILURES) || 3
+      },
+
+      // Notification settings
+      notifications: {
+        enabled: process.env.MONITOR_NOTIFICATIONS_ENABLED !== 'false',
+        cooldown: parseInt(process.env.MONITOR_NOTIFICATION_COOLDOWN) || 300000, // 5 minutes
+        
+        email: {
+          enabled: process.env.MONITOR_EMAIL_ENABLED === 'true',
+          host: process.env.MONITOR_EMAIL_HOST || 'smtp.gmail.com',
+          port: parseInt(process.env.MONITOR_EMAIL_PORT) || 587,
+          secure: process.env.MONITOR_EMAIL_SECURE === 'true',
+          auth: {
+            user: process.env.MONITOR_EMAIL_USER || '',
+            pass: process.env.MONITOR_EMAIL_PASS || ''
+          },
+          from: process.env.MONITOR_EMAIL_FROM || '',
+          recipients: process.env.MONITOR_EMAIL_RECIPIENTS 
+            ? process.env.MONITOR_EMAIL_RECIPIENTS.split(',') 
+            : []
+        },
+
+        slack: {
+          enabled: process.env.MONITOR_SLACK_ENABLED === 'true',
+          webhook: process.env.MONITOR_SLACK_WEBHOOK || '',
+          channel: process.env.MONITOR_SLACK_CHANNEL || '#monitoring',
+          username: process.env.MONITOR_SLACK_USERNAME || 'Node Monitor'
+        },
+
+        sms: {
+          enabled: process.env.MONITOR_SMS_ENABLED === 'true',
+          provider: process.env.MONITOR_SMS_PROVIDER || 'twilio',
+          accountSid: process.env.MONITOR_SMS_ACCOUNT_SID || '',
+          authToken: process.env.MONITOR_SMS_AUTH_TOKEN || '',
+          from: process.env.MONITOR_SMS_FROM || '',
+          recipients: process.env.MONITOR_SMS_RECIPIENTS 
+            ? process.env.MONITOR_SMS_RECIPIENTS.split(',') 
+            : []
+        }
+      },
+
+      // Logging configuration
+      logging: {
+        enabled: process.env.MONITOR_LOGGING_ENABLED !== 'false',
+        level: process.env.MONITOR_LOG_LEVEL || 'info',
+        directory: process.env.MONITOR_LOG_DIRECTORY || './logs',
+        maxFiles: process.env.MONITOR_LOG_MAX_FILES || '14d',
+        maxSize: process.env.MONITOR_LOG_MAX_SIZE || '20m',
+        format: process.env.MONITOR_LOG_FORMAT || 'json', // 'json' or 'simple'
+        console: process.env.MONITOR_LOG_CONSOLE !== 'false'
+      },
+
+      // Health check configuration
+      healthCheck: {
+        enabled: process.env.MONITOR_HEALTH_CHECK_ENABLED !== 'false',
+        endpoint: process.env.MONITOR_HEALTH_ENDPOINT || '/health',
+        timeout: parseInt(process.env.MONITOR_HEALTH_TIMEOUT) || 5000
+      },
+
+      // Database monitoring
+      database: {
+        enabled: process.env.MONITOR_DATABASE_ENABLED !== 'false',
+        types: [], // Will be populated based on connections provided
+        queryTimeout: parseInt(process.env.MONITOR_DB_QUERY_TIMEOUT) || 5000
+      },
+
+      // System monitoring
+      system: {
+        enabled: process.env.MONITOR_SYSTEM_ENABLED !== 'false',
+        trackCpu: process.env.MONITOR_TRACK_CPU !== 'false',
+        trackMemory: process.env.MONITOR_TRACK_MEMORY !== 'false',
+        trackEventLoop: process.env.MONITOR_TRACK_EVENT_LOOP === 'true'
+      },
+
+      // Error tracking
+      errorTracking: {
+        enabled: process.env.MONITOR_ERROR_TRACKING_ENABLED !== 'false',
+        captureStackTrace: process.env.MONITOR_CAPTURE_STACK_TRACE !== 'false',
+        sanitizeSensitiveData: process.env.MONITOR_SANITIZE_DATA !== 'false',
+        sensitiveFields: ['password', 'token', 'apiKey', 'secret', 'authorization']
+      },
+
+      // Application metadata
+      app: {
+        name: process.env.MONITOR_APP_NAME || process.env.npm_package_name || 'nodejs-app',
+        environment: process.env.NODE_ENV || 'development',
+        version: process.env.MONITOR_APP_VERSION || process.env.npm_package_version || '1.0.0',
+        hostname: process.env.HOSTNAME || require('os').hostname()
+      }
+    };
+  }
+
+  /**
+   * Deep merge user config with defaults
+   */
+  mergeWithDefaults(userConfig) {
+    const defaults = this.getDefaults();
+    return this.deepMerge(defaults, userConfig);
+  }
+
+  /**
+   * Deep merge utility
+   */
+  deepMerge(target, source) {
+    const output = { ...target };
+    
+    if (this.isObject(target) && this.isObject(source)) {
+      Object.keys(source).forEach(key => {
+        if (this.isObject(source[key])) {
+          if (!(key in target)) {
+            output[key] = source[key];
+          } else {
+            output[key] = this.deepMerge(target[key], source[key]);
+          }
+        } else {
+          output[key] = source[key];
+        }
+      });
+    }
+    
+    return output;
+  }
+
+  /**
+   * Check if value is an object
+   */
+  isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+  }
+
+  /**
+   * Validate configuration
+   */
+  validateConfig() {
+    const errors = [];
+
+    // Validate intervals
+    if (this.config.intervals.health < 1000) {
+      errors.push('Health check interval must be at least 1000ms');
+    }
+
+    // Validate thresholds
+    if (this.config.thresholds.cpu < 0 || this.config.thresholds.cpu > 100) {
+      errors.push('CPU threshold must be between 0 and 100');
+    }
+    if (this.config.thresholds.memory < 0 || this.config.thresholds.memory > 100) {
+      errors.push('Memory threshold must be between 0 and 100');
+    }
+
+    // Validate email config if enabled
+    if (this.config.notifications.email.enabled) {
+      if (!this.config.notifications.email.auth.user || !this.config.notifications.email.auth.pass) {
+        errors.push('Email notifications enabled but credentials not provided');
+      }
+      if (this.config.notifications.email.recipients.length === 0) {
+        errors.push('Email notifications enabled but no recipients specified');
+      }
+    }
+
+    // Validate Slack config if enabled
+    if (this.config.notifications.slack.enabled) {
+      if (!this.config.notifications.slack.webhook) {
+        errors.push('Slack notifications enabled but webhook URL not provided');
+      }
+    }
+
+    // Validate SMS config if enabled
+    if (this.config.notifications.sms.enabled) {
+      if (!this.config.notifications.sms.accountSid || !this.config.notifications.sms.authToken) {
+        errors.push('SMS notifications enabled but credentials not provided');
+      }
+      if (this.config.notifications.sms.recipients.length === 0) {
+        errors.push('SMS notifications enabled but no recipients specified');
+      }
+    }
+
+    if (errors.length > 0) {
+      throw new Error(`Configuration validation failed:\n${errors.join('\n')}`);
+    }
+  }
+
+  /**
+   * Get configuration value by path
+   */
+  get(path) {
+    return path.split('.').reduce((obj, key) => obj?.[key], this.config);
+  }
+
+  /**
+   * Set configuration value by path
+   */
+  set(path, value) {
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    const target = keys.reduce((obj, key) => obj[key], this.config);
+    target[lastKey] = value;
+  }
+
+  /**
+   * Get all configuration
+   */
+  getAll() {
+    return { ...this.config };
+  }
+
+  /**
+   * Get sanitized config (without sensitive data) for logging
+   */
+  getSanitized() {
+    const sanitized = JSON.parse(JSON.stringify(this.config));
+    
+    // Remove sensitive fields
+    if (sanitized.notifications?.email?.auth) {
+      sanitized.notifications.email.auth.pass = '***';
+    }
+    if (sanitized.notifications?.sms) {
+      sanitized.notifications.sms.authToken = '***';
+    }
+    
+    return sanitized;
+  }
+}
+
+module.exports = MonitoringConfig;
+