تحسين الأداء

// 1. استخدام محلل Node.js المدمج
node --prof server.js

// هذا ينشئ ملفًا: isolate-0x....-v8.log
// معالجته للحصول على إخراج قابل للقراءة
node --prof-process isolate-0x....-v8.log > processed.txt

// 2. استخدام Chrome DevTools للتحليل
node --inspect server.js
// افتح chrome://inspect في متصفح Chrome
// انقر على "inspect" لفتح DevTools
// انتقل إلى علامة التبويب "Profiler" لتسجيل ملفات تعريف CPU

// 3. استخدام clinic.js للتشخيص الشامل
npm install -g clinic

// Doctor - كشف مشاكل الأداء
clinic doctor -- node server.js

// Bubbleprof - تحليل العمليات غير المتزامنة
clinic bubbleprof -- node server.js

// Flame - تحليل CPU
clinic flame -- node server.js

// كشف تسرب الذاكرة
const heapdump = require('heapdump');

// أخذ لقطة من الذاكرة
app.get('/heapdump', (req, res) => {
  heapdump.writeSnapshot(\`./heapdump-${Date.now()}.heapsnapshot\`, (err, filename) => {
    if (err) return res.status(500).send(err);
    res.send(`تم كتابة تفريغ الذاكرة إلى ${filename}`);
  });
});

// سيئ: مثال على تسرب الذاكرة
const cache = {};
app.get('/cache/:key', (req, res) => {
  cache[req.params.key] = req.body; // التخزين المؤقت ينمو بلا حدود!
  res.send('تم التخزين المؤقت');
});

// جيد: ذاكرة تخزين مؤقت محدودة مع LRU (الأقل استخدامًا مؤخرًا)
const LRU = require('lru-cache');
const cache = new LRU({
  max: 500,           // بحد أقصى 500 عنصر
  maxAge: 1000 * 60 * 60 // تنتهي صلاحية العناصر بعد ساعة واحدة
});

app.get('/cache/:key', (req, res) => {
  cache.set(req.params.key, req.body);
  res.send('تم التخزين المؤقت');
});

// سيئ: تسرب مستمع الحدث
class BadEmitter extends EventEmitter {
  addListener() {
    this.on('data', () => {
      // معالجة البيانات
    });
    // لا تتم إزالة المستمع أبدًا!
  }
}

// جيد: إزالة المستمعين
class GoodEmitter extends EventEmitter {
  addListener() {
    const handler = () => { /* معالجة البيانات */ };
    this.on('data', handler);

    // تنظيف عند الانتهاء
    this.once('close', () => {
      this.removeListener('data', handler);
    });
  }
}

// سيئ: حظر حلقة الحدث
app.get('/calculate', (req, res) => {
  let result = 0;
  for (let i = 0; i < 10000000000; i++) {
    result += Math.sqrt(i);
  }
  res.json({ result });
});

// جيد: نقل العمل كثيف الاستخدام للمعالج إلى خيوط العمال
const { Worker } = require('worker_threads');

app.get('/calculate', (req, res) => {
  const worker = new Worker('./calc-worker.js');

  worker.on('message', (result) => {
    res.json({ result });
  });

  worker.on('error', (err) => {
    res.status(500).json({ error: err.message });
  });

  worker.postMessage({ iterations: 10000000000 });
});

// calc-worker.js
const { parentPort } = require('worker_threads');

parentPort.on('message', ({ iterations }) => {
  let result = 0;
  for (let i = 0; i < iterations; i++) {
    result += Math.sqrt(i);
  }
  parentPort.postMessage(result);
});

const Redis = require('redis');
const redisClient = Redis.createClient({
  host: 'localhost',
  port: 6379
});

// وسيط التخزين المؤقت
const cacheMiddleware = (duration) => {
  return async (req, res, next) => {
    const key = `cache:${req.originalUrl}`;

    try {
      const cachedData = await redisClient.get(key);

      if (cachedData) {
        console.log('إصابة التخزين المؤقت!');
        return res.json(JSON.parse(cachedData));
      }

      // تعديل res.json لتخزين الاستجابة مؤقتًا
      const originalJson = res.json.bind(res);
      res.json = (data) => {
        redisClient.setEx(key, duration, JSON.stringify(data));
        return originalJson(data);
      };

      next();
    } catch (err) {
      console.error('خطأ في التخزين المؤقت:', err);
      next();
    }
  };
};

// استخدام التخزين المؤقت
app.get('/api/products', cacheMiddleware(3600), async (req, res) => {
  const products = await db.query('SELECT * FROM products');
  res.json(products);
});

// إبطال التخزين المؤقت
app.post('/api/products', async (req, res) => {
  const product = await db.insert(req.body);

  // إبطال ذاكرة التخزين المؤقت ذات الصلة
  await redisClient.del('cache:/api/products');

  res.json(product);
});

const compression = require('compression');

// تمكين الضغط
app.use(compression({
  level: 6,           // مستوى الضغط (0-9)
  threshold: 1024,    // ضغط الاستجابات فقط > 1KB
  filter: (req, res) => {
    // لا تضغط إذا كان العميل لا يدعمه
    if (req.headers['x-no-compression']) {
      return false;
    }
    return compression.filter(req, res);
  }
}));

// يقلل الضغط من حجم الاستجابة بنسبة 60-80٪ لمحتوى النص!

// سيئ: مشكلة استعلام N+1
const users = await db.query('SELECT * FROM users');
for (const user of users) {
  user.posts = await db.query('SELECT * FROM posts WHERE user_id = ?', [user.id]);
}

// جيد: استعلام واحد مع JOIN
const usersWithPosts = await db.query(`
  SELECT
    users.*,
    JSON_ARRAYAGG(
      JSON_OBJECT('id', posts.id, 'title', posts.title)
    ) as posts
  FROM users
  LEFT JOIN posts ON posts.user_id = users.id
  GROUP BY users.id
`);

// استخدام الترقيم لمجموعات البيانات الكبيرة
app.get('/api/posts', async (req, res) => {
  const page = parseInt(req.query.page) || 1;
  const limit = 20;
  const offset = (page - 1) * limit;

  const posts = await db.query(
    'SELECT * FROM posts ORDER BY created_at DESC LIMIT ? OFFSET ?',
    [limit, offset]
  );

  const total = await db.query('SELECT COUNT(*) as count FROM posts');

  res.json({
    posts,
    pagination: {
      page,
      limit,
      total: total[0].count,
      pages: Math.ceil(total[0].count / limit)
    }
  });
});

const mysql = require('mysql2/promise');

// إنشاء تجمع الاتصال
const pool = mysql.createPool({
  host: 'localhost',
  user: 'root',
  password: 'password',
  database: 'myapp',
  waitForConnections: true,
  connectionLimit: 10,      // بحد أقصى 10 اتصالات متزامنة
  queueLimit: 0,            // قائمة انتظار غير محدودة
  enableKeepAlive: true,
  keepAliveInitialDelay: 0
});

// استخدام التجمع للاستعلامات
app.get('/api/users', async (req, res) => {
  try {
    const [rows] = await pool.execute('SELECT * FROM users');
    res.json(rows);
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'خطأ في قاعدة البيانات' });
  }
});

// مراقبة حالة التجمع
setInterval(() => {
  console.log('اتصالات التجمع:', pool.pool._allConnections.length);
  console.log('الاتصالات النشطة:', pool.pool._acquiringConnections.length);
}, 30000);

// سيئ: تحميل كل شيء مقدمًا
const heavyModule = require('./heavy-module');

app.get('/heavy-operation', (req, res) => {
  const result = heavyModule.process(req.body);
  res.json(result);
});

// جيد: التحميل الكسول للوحدات عند الحاجة
app.get('/heavy-operation', async (req, res) => {
  // فقط تطلب الوحدة عند الوصول إلى هذا المسار
  const heavyModule = require('./heavy-module');
  const result = await heavyModule.process(req.body);
  res.json(result);
});

// أفضل: استخدام الواردات الديناميكية للتحميل غير المتزامن
app.get('/heavy-operation', async (req, res) => {
  const { default: heavyModule } = await import('./heavy-module.mjs');
  const result = await heavyModule.process(req.body);
  res.json(result);
});

const promClient = require('prom-client');

// إنشاء سجل
const register = new promClient.Registry();

// إضافة المقاييس الافتراضية
promClient.collectDefaultMetrics({ register });

// مقاييس مخصصة
const httpRequestDuration = new promClient.Histogram({
  name: 'http_request_duration_seconds',
  help: 'مدة طلبات HTTP بالثواني',
  labelNames: ['method', 'route', 'status_code'],
  buckets: [0.1, 0.5, 1, 2, 5]
});
register.registerMetric(httpRequestDuration);

// قياس مدة الطلب
app.use((req, res, next) => {
  const start = Date.now();

  res.on('finish', () => {
    const duration = (Date.now() - start) / 1000;
    httpRequestDuration
      .labels(req.method, req.route?.path || req.path, res.statusCode)
      .observe(duration);
  });

  next();
});

// نقطة نهاية المقاييس
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', register.contentType);
  res.end(await register.metrics());
});