Feature Flags in Node.js Backend with LaunchDarkly (thombergs#204)

* nodejs-launchdarkly

* segregating code examples

* refactoring the code sections

* refactor directory name

* minor changes

* addressed review comments

* review comments

* review comments

Co-authored-by: Arpendu Kumar Garai <[email protected]>

Author: arpendu11

nodejs/nodejs-backend-admin-feature-flag-launchdarkly/bootstrap.js

@@ -0,0 +1,33 @@
+import util from 'util';
+import express from 'express';
+import LaunchDarkly from 'launchdarkly-node-server-sdk';
+import Logger from './logger.js';
+
+const PORT = 5000;
+const app = express();
+const simpleLogger = new Logger('SimpleLogging');
+
+const LD_SDK_KEY = 'sdk-********-****-****-****-************';
+const LOG_LEVEL_FLAG_KEY = 'backend-log-level';
+const client = LaunchDarkly.init(LD_SDK_KEY);
+const asyncGetFlag = util.promisify(client.variation);
+
+client.once('ready', async () => {
+  const user = {
+    anonymous: true
+  };
+  const initialLogLevel = await asyncGetFlag(LOG_LEVEL_FLAG_KEY, user, 'debug');
+  Logger.setLogLevel(initialLogLevel);
+
+  app.get('/', (req, res) => {
+    simpleLogger.debug('detailed debug message');
+    simpleLogger.log('simple log message');
+    simpleLogger.warn('Warning warning do something');
+    simpleLogger.error('ERROR! ERROR!');
+    res.sendStatus(200);
+  });
+
+  app.listen(PORT, () => {
+    simpleLogger.log(`Server listening on port ${PORT}`);
+  });
+});

nodejs/nodejs-backend-admin-feature-flag-launchdarkly/cron_job.js

@@ -0,0 +1,56 @@
+import cron from 'cron';
+import LaunchDarkly from 'launchdarkly-node-server-sdk';
+
+const CronJob = cron.CronJob;
+const CronTime = cron.CronTime;
+
+// Initiating LaunchDarkly Client
+const LD_SDK_KEY = 'sdk-********-****-****-****-************';
+const userName = 'admin';
+const launchDarklyClient = LaunchDarkly.init( LD_SDK_KEY );
+
+launchDarklyClient.once('ready', async () => {    
+    const cronConfig = await launchDarklyClient.variation(
+      'cron-config',
+      {
+          key: userName
+      },
+      '*/4 * * * *' // Default fall-back variation value.
+    );
+
+    const job = new CronJob(cronConfig, function() {
+      run();
+    }, null, false)
+
+    let run = () => {
+      console.log('scheduled task called');
+    }
+
+    let scheduler = () => {
+      console.log('CRON JOB STARTED WILL RUN AS PER LAUNCHDARKLY CONFIG');
+      job.start();
+    }
+
+    let schedulerStop = () => {
+      job.stop();
+      console.log('scheduler stopped');
+    }
+
+    let schedulerStatus = () => {
+      console.log('cron status ---->>>', job.running);
+    }
+
+    let changeTime = (input) => {
+      job.setTime(new CronTime(input));
+      console.log('changed to every 1 second');
+    }
+
+    scheduler();
+    setTimeout(() => {schedulerStatus()}, 1000);
+    setTimeout(() => {schedulerStop()}, 9000);
+    setTimeout(() => {schedulerStatus()}, 10000);
+    setTimeout(() => {changeTime('* * * * * *')}, 11000);
+    setTimeout(() => {scheduler()}, 12000);
+    setTimeout(() => {schedulerStop()}, 16000);
+  }
+);

nodejs/nodejs-backend-admin-feature-flag-launchdarkly/dynamic_logger.js

@@ -0,0 +1,74 @@
+import { format } from 'date-fns';
+import padEnd from 'lodash/padEnd.js';
+import capitalize from 'lodash/capitalize.js';
+
+class DynamicLogger {
+  constructor( module, ldClient, flagKey, user ) {
+    this.module = module ? module : '';
+    this.ldClient = ldClient;
+	  this.flagKey = flagKey;
+	  this.user = user;
+	  this.previousLevel = null; 
+  }
+
+  writeToConsole(level, message) {
+      const dateTime = format(new Date(), 'MM-dd-yyyy HH:mm:ss:SSS');
+      const formattedLevel = padEnd(capitalize(level), 5);
+      const formattedMessage = `${dateTime} ${formattedLevel} [${
+        this.module
+      }] ${message}`;
+      console[level](formattedMessage, '');
+  }
+
+  async debug( message ) { 
+    if ( await this._presentLog( 'debug' ) ) {
+        this.writeToConsole('debug', message); 
+    } 
+  }
+
+  async error( message ) { 
+    if ( await this._presentLog( 'error' ) ) {
+        this.writeToConsole('error', message); 
+    } 
+  }
+
+  async info( message ) { 
+    if ( await this._presentLog( 'info' ) ) {
+        this.writeToConsole('info', message); 
+    } 
+  }
+
+  async warn( message ) { 
+    if ( await this._presentLog( 'warn' ) ) {
+        this.writeToConsole('warn', message); 
+    }
+  }
+
+  async _presentLog( level ) {
+
+    const minLogLevel = await this.ldClient.variation(
+        this.flagKey,
+        {
+           key: this.user
+        },
+        'debug' // Default/fall-back value if LaunchDarkly unavailable.
+    );
+
+    if ( minLogLevel !== this.previousLevel ) { 
+       console.log( `Present log-level: ${ minLogLevel }` ); 
+    }
+        
+    switch ( this.previousLevel = minLogLevel ) {
+        case 'error':
+            return level === 'error';
+        case 'warn':
+            return level === 'error' ||	level === 'warn';
+        case 'info':
+            return level === 'error' || level === 'warn' || level === 'info';
+        default:
+            return true;
+        } 
+    }
+}
+
+export default DynamicLogger;

nodejs/nodejs-backend-admin-feature-flag-launchdarkly/dynamic_logging.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+import LaunchDarkly from 'launchdarkly-node-server-sdk';
+import DynamicLogger from './dynamic_logger.js';
+
+const LD_SDK_KEY = 'sdk-********-****-****-****-************';
+const flagKey = 'backend-log-level';
+const userName = 'admin';
+const launchDarklyClient = LaunchDarkly.init( LD_SDK_KEY );
+let logger;
+let loop = 0;
+
+launchDarklyClient.once('ready', async () => {
+		setTimeout( executeLoop, 1000 ); 
+	}
+);
+
+async function executeLoop () {
+	logger = new DynamicLogger( 'DynamicLogging', launchDarklyClient, flagKey, userName );
+	console.log( chalk.dim.italic( `Loop ${ ++loop }` ) ); 
+	logger.debug( 'Executing loop.' );
+	logger.debug('This is a debug log.');
+	logger.info('This is an info log.');
+	logger.warn('This is a warn log.');
+	logger.error('This is a error log.');
+	setTimeout( executeLoop, 1000 ); 
+}

nodejs/nodejs-backend-admin-feature-flag-launchdarkly/index.js

@@ -0,0 +1,28 @@
+import LaunchDarkly from 'launchdarkly-node-server-sdk';
+import express from 'express';
+
+const app = express();
+
+app.get("/", async (req, res) => {
+  const flags = await init();
+  res.send(flags);
+});
+app.listen(8080);
+
+const LD_SDK_KEY = 'sdk-********-****-****-****-************';
+const userName = 'admin';
+let client;
+
+async function init() {
+  if (!client) {
+    client = LaunchDarkly.init(LD_SDK_KEY);
+    await client.waitForInitialization();
+  }
+
+  const user = {
+    key: userName
+  };
+  const allFlagsState = await client.allFlagsState(user);
+  const flags = allFlagsState.allValues();
+  return flags;
+}

nodejs/nodejs-backend-admin-feature-flag-launchdarkly/logger.js

@@ -0,0 +1,55 @@
+import { format } from 'date-fns';
+import padEnd from 'lodash/padEnd.js';
+import capitalize from 'lodash/capitalize.js';
+
+const LEVELS = { debug: 10, log: 20, warn: 30, error: 40 };
+let currentLogLevel = LEVELS['debug'];
+
+class Logger {
+  constructor(module) {
+    this.module = module ? module : '';
+
+    this.debug = this.debug.bind(this);
+    this.log = this.log.bind(this);
+    this.warn = this.warn.bind(this);
+    this.error = this.error.bind(this);
+    this.writeToConsole = this.writeToConsole.bind(this);
+  }
+
+  static setLogLevel(level) {
+    currentLogLevel = LEVELS[level];
+  }
+
+  static get(module) {
+    return new Logger(module);
+  }
+
+  writeToConsole(level, message, context = '') {
+    if (LEVELS[level] >= currentLogLevel) {
+      const dateTime = format(new Date(), 'MM-dd-yyyy HH:mm:ss:SSS');
+      const formattedLevel = padEnd(capitalize(level), 5);
+      const formattedMessage = `${dateTime} ${formattedLevel} [${
+        this.module
+      }] ${message}`;
+      console[level](formattedMessage, context);
+    }
+  }
+
+  debug(message, context) {
+    this.writeToConsole('debug', message, context);
+  }
+
+  log(message, context) {
+    this.writeToConsole('log', message, context);
+  }
+
+  warn(message, context) {
+    this.writeToConsole('warn', message, context);
+  }
+
+  error(message, context) {
+    this.writeToConsole('error', message, context);
+  }
+}
+
+export default Logger;

nodejs/nodejs-backend-admin-feature-flag-launchdarkly/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "nodejs-backend-feature-flag-launchdarkly",
+  "version": "1.0.0",
+  "description": "Feature Flags in Node.js backend server with LaunchDarkly",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js",
+    "bootstrap": "node bootstrap.js",
+    "dynamic": "node dynamic_logging.js",
+    "rateLimiter": "node rate_limiter.js",
+    "cron": "node cron_job.js"
+  },
+  "author": "Arpendu Kumar Garai",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "4.1.2",
+    "cors": "^2.8.5",
+    "cron": "^2.1.0",
+    "date-fns": "^2.28.0",
+    "express": "^4.18.1",
+    "express-rate-limit": "^6.5.1",
+    "launchdarkly-node-server-sdk": "^6.4.2",
+    "lodash": "^4.17.21"
+  }
+}

nodejs/nodejs-backend-admin-feature-flag-launchdarkly/rate_limiter.js

@@ -0,0 +1,66 @@
+import bodyParser from 'body-parser';
+import express from 'express';
+import cors from 'cors';
+import rateLimit from 'express-rate-limit';
+import LaunchDarkly from 'launchdarkly-node-server-sdk';
+import LdLogger from './ld_logger.js';
+
+// Initiating LaunchDarkly Client
+const LD_SDK_KEY = 'sdk-d2432dc7-e56a-458b-9f93-0361af47d578';
+const userName = 'admin';
+const launchDarklyClient = LaunchDarkly.init( LD_SDK_KEY );
+
+// Initiating the Logger
+const flagKey = 'backend-log-level';
+let logger;
+launchDarklyClient.once('ready', async () => {
+    logger = new LdLogger( launchDarklyClient, flagKey, userName );
+    serverInit();
+  }
+);
+
+const serverInit = async () => {
+
+    // Essential globals
+    const app = express();
+
+    //  Initialize global application middlewares
+    app.use(cors());
+    app.use(
+        bodyParser.urlencoded({
+            extended: true
+        })
+    );
+    app.use(
+        bodyParser.json({
+            type: 'application/json'
+        })
+    );
+    
+    // Initialize Rate Limit Midlleware
+    const rateLimiterConfig = await launchDarklyClient.variation(
+        'rate-limiter-config',
+        {
+            key: userName // The static "user" for this task.
+        },
+        {
+            windowMs: 24 * 60 * 60 * 1000, // 24 hrs in milliseconds
+            max: 100, // Limit each IP to 100 requests per `window`
+            // (here, per 24 hours). Set it to 0 to disable rateLimiter
+            message: 'You have exceeded 100 requests in 24 hrs limit!', 
+            standardHeaders: true, // Return rate limit info in the `RateLimit-*` headers
+            legacyHeaders: false, // Disable the `X-RateLimit-*` headers
+        } // Default/fall-back value
+    );
+    app.use(rateLimit(rateLimiterConfig));
+
+    // Initialize API
+    app.get('/hello', function (req, res) {
+        return res.send('Hello World')
+    });
+
+    // Initialize server
+    app.listen(5000, () => {
+        logger.info('Starting server on  port 5000');
+    });
+};