Let’s hop right on and start with Microservices Architecture:

• Microservices Architecture: An example of using microservices in a Node.js application would be to separate user management and product management into different services. Each service can be developed, deployed, and scaled independently.

// User Microservice 
const express = require('express');
const app = express();
const port = process.env.PORT || 3000;
app.get('/users', (req, res) => {
    // code to handle user management
});
app.listen(port, () => {
    console.log(`User Microservice running on ${port}`);
});
// Product Microservice
const express = require('express');
const app = express();
const port = process.env.PORT || 3001;
app.get('/products', (req, res) => {
    // code to handle product management
});
app.listen(port, () => {
    console.log(`Product Microservice running on ${port}`);
});

• Load Balancer: An example of using a load balancer in a Node.js application would be to use a package like ‘express-http-proxy’, which allows you to proxy requests to different servers based on the route.

const proxy = require('express-http-proxy');
const app = express();
app.use('/users', proxy('http://user-microservice:3000'));
app.use('/products', proxy('http://product-microservice:3001'));
app.listen(3000, () => {
    console.log('Load balancer running on 3000');
});

• Horizontal Scaling: An example of using MongoDB for horizontal scaling would be to use sharding to distribute data across multiple servers.

// Connect to MongoDB Cluster
const MongoClient = require('mongodb').MongoClient;
const uri = "mongodb+srv://:@cluster.mongodb.net/test?retryWrites=true&w=majority";
const client = new MongoClient(uri, { useNewUrlParser: true });
client.connect(err => {
  const collection = client.db("test").collection("devices");
  // Perform actions on the collection object
  client.close();
});

• Cloud-based Infrastructure: An example of using AWS for scaling would be to use Amazon Elastic Compute Cloud (EC2) for deploying and scaling the application.

// AWS SDK for Node.js
const AWS = require('aws-sdk');
// Set the region 
AWS.config.update({region: 'REGION'});
// Create EC2 service object
var ec2 = new AWS.EC2({apiVersion: '2016-11-15'});
var params = {
  DryRun: false,
  InstanceCount: 2, // Number of instances
  InstanceType: 't2.micro', // Instance type
  LaunchTemplate: {
    LaunchTemplateId: 'lt-01234567890abcdef0', // ID of the launch template
    Version: '1'
  },
  TagSpecifications: [
    {
      ResourceType: 'instance',
      Tags: [
        {
          Key: 'Name',
          Value: 'MyInstance
}]
};
// Create the instances
ec2.runInstances(params, function(err, data) {
   if (err) {
      console.log("Error", err);
   } else {
      console.log("Success", data);
   }
});

• Caching: An example of using caching in a Node.js application would be to use a package like ‘memcached’ to cache frequently-used data.

const memcached = require('memcached');
const client = new memcached('localhost:11211');
// Set data in cache
client.set('key', 'value', 3600, function(err) {});
// Get data from cache
client.get('key', function(err, data) {
   console.log(data);
});

Note: This is just a simple example of how to use memcached package, you may need to adjust it according to your use case. There are other caching technologies that you can use as well such as Redis, Varnish and so on.

• Monitoring and logging: An example of using monitoring and logging in a Node.js application would be to use a package like ‘winston’ for logging and ‘prom-client’ for monitoring.

const winston = require('winston');
const promClient = require('prom-client');
// Logging
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
    new winston.transports.Console({
        format: winston.format.simple()
    })
  ]
});
logger.info('Hello log');
// Monitoring
const httpRequestDurationMicroseconds = new promClient.Histogram({
  name: 'http_request_duration_ms',
  help: 'Duration of HTTP requests in ms',
  labelNames: ['route'],
  // buckets for response time from 0.1ms to 500ms
  buckets: [0.10, 5, 15, 50, 100, 200, 300, 400, 500]
});
app.use((req, res, next) => {
    const end = httpRequestDurationMicroseconds.startTimer();
    res.on('finish', () => {
        end({ route: req.url });
    });
    next();
});

• Continuously test and measure: To continuously test and measure the app performance, you can use tools like Apache JMeter, Gatling or Loader.io. These tools allow you to simulate a high number of users and measure the app’s performance under load.

// Using Apache JMeter
- Install and run Apache JMeter on your machine
- Create a test plan and add the necessary elements (Thread Group, HTTP Request, etc)
- Configure the test plan to simulate the desired number of users and requests
- Run the test plan and analyze the results