npm package readme created

Author: Fredwards

chronos_npm_package/README.md

@@ -68,7 +68,7 @@ The `database` property is required and takes in the following:
 - `URI` should be a connection string to the database where you intend Chronos to write and record data regarding health, HTTP route tracing, and container infomation.
 We reccommend using dotenv  
 
-Wherever you create an instance of your server (see example below),
+You will also need to add the following two lines of code to your express server:,
 
 ```js
 // Example for REST
@@ -77,7 +77,7 @@ const app = express();
 
 ```
 
-you will also need to require in `chronos-tracker` and initialize Chronos, as well as the `./chronos-config` file. You will then need to invoke `chronos.propagate()` to initiate the route tracing, in addition to implementing `chronos.track()` for all endpoints.
+you will also need to require in `chronos-tracker-7` and initialize Chronos, as well as the `./chronos-config` file in addition to implementing `chronos.track()` for all endpoints.
 
 ```js
 const chronos = require('chronos-tracker');
@@ -88,6 +88,224 @@ require('./chronos-config'); // Bring in config file
 app.use('/', chronos.track());
 ```
 
-You should be good to go! The last step, **Docker Configuration**, is **only applicable** if you need to configure <a href="#"><img src="./app/assets/docker-logo-color.png" alt="Docker" title="Docker" align="center" height="20" /></a> for your application. 
+You should be good to go! The steps below for **Docker Configuration** and **Kafka Configuration**, are **only applicable** if you need to configure <a href="#"><img src="./app/assets/docker-logo-color.png" alt="Docker" title="Docker" align="center" height="20" /></a> or Kafka for your application. See the **Notifications** section below for information on how to uses the notifications propery in `chronos-config.js`.
 
 <br>
+
+#### Initialize Chronos Tracker for gRPC
+
+Wherever you create an instance of your server (see example below),
+
+
+```js
+  // Example of gRPC server
+  const server = new grpc.Server();
+
+  server.bindAsync("127.0.0.1:30044", grpc.   ServerCredentials.createInsecure(), () => {
+    server.start();
+    console.log("Server running at http://127.0.0.1:30044");
+});
+```
+you will also need to require Chronos-tracker, Chronos-config, and dotenv.config(if this is used). For health data, simply use Chronos.track()
+
+
+
+```js
+//track health data
+const chronos = require('chronos-tracker');
+require('./chronos-config');
+require('dotenv').config(); // set up environment variables in .env
+const BookModel = require('./BookModel');
+
+chronos.track()
+```
+To trace requests, first wrap the gRPC client using Chronos
+```js
+const grpc = require('@grpc/grpc-js');
+const protoLoader = require('@grpc/proto-loader');
+const chronos = require('chronos');
+
+const PROTO_PATH = './order.proto';
+
+const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  arrays: true,
+});
+const OrderToBookService = grpc.loadPackageDefinition(packageDefinition).OrderToBook;
+const bookClient = new OrderToBookService('localhost:30044', grpc.credentials.createInsecure());
+
+const ClientWrapper = chronos.ClientWrapper(bookClient, OrderToBookService);
+```
+Next wrap the gRPC server using Chronos 
+```js
+
+  const ServerWrapper = chronos.ServerWrapper(server,  Proto.protoname.service, {
+    AddBook: (call, callback) => {
+    // console.log(call.metadata)
+    // get the properties from the gRPC client call
+      const { title, author, numberOfPages, publisher, bookID } = call.request;
+    // create a book in our book collection
+      BookModel.create({
+        title,
+        author,
+        numberOfPages,
+        publisher,
+        bookID,
+      });
+      callback(null, {});
+    },
+  });
+
+```
+For any request you wish to trace, require uuidv4 and write the following code where the initial gRPC request begins,
+```js
+const require { v4: uuidv4} = require('uuid')
+const createMeta = () => {
+  const meta = new grpc.Metadata();
+  meta.add('id', uuidvd());
+  return meta
+}
+```
+and then, invoke createMeta as a third argument to any client method that is the beginning of the request path.
+
+```js
+orderClient.AddOrder(
+    order,
+    (err, data) => {
+      if (err !== null) {
+        console.log(err);
+        // could not add order because bookID does not exist
+        return res.sendStatus(404);
+      }
+      console.log('addOrder response: ', data);
+      return res.sendStatus(200);
+    },
+    createMeta()
+  );
+
+```
+Finally, on all servers that will be involved in the request path, invoke `chronos.link` with parameters of `client` and `ServerWrapper` in the server wrapper.
+
+```js
+chronos.link(client, ServerWrapper);
+```
+
+### Apache Monitoring (Via JMX to Prometheus Exporter)
+
+Chronos now offers the ability to monitor an Apache Kafka cluster via JMX to Prometheus Exporter. In order for this feature to work you must be running [JMX to Prometheus
+Exporter](https://github.com/prometheus/jmx_exporter) either as a Java Agent with your cluster or as a standalone HTTP server. Then, use `chronos-config.js` to specifiy the port exposed for metrics scraping.
+
+To start, add the property `jmxuri` to the object in `chronos-config.js`. Your file should look similar to this:
+
+```js
+// A sample `chronos-config.js` file
+
+const chronos = require('chronos-tracker-7');
+
+chronos.use({
+  microservice: 'payments',
+  interval: 5000,
+  dockerized: true,
+  jmxuri: // your URI here
+  database: {
+    connection: 'REST',
+    type: 'MongoDB',
+    URI: process.env.URI,
+  },
+  notifications: [],
+});
+```
+The `jmxuri` property should be a string whose value is the port specified for scraping when starting the exporter.
+
+Then, in ***ONE AND ONLY ONE** of your microservices, call
+
+```js
+
+chronos.kafka()
+
+```
+
+in your express server. When viewing your information in the Chronos Electron application the data will be available in the service "kafkametrics"
+
+### Docker Configuration
+
+Again, this step is **only applicable** if you are currently using <a href="#"><img src="./app/assets/docker-logo-color.png" alt="Docker" title="Docker" align="center" height="20" /></a> containers for your microservices. 
+
+<a href="#"><img src="./app/assets/important.png" alt="Important" title="Important" align="center" height="20" /></a> Give your containers the same names you pass in as arguments for microservice names.
+
+<a href="#"><img src="./app/assets/important.png" alt="Important" title="Important" align="center" height="20" /></a> In order to have container statistics saved to your database along with other health info, bind volumes to this path when starting up the containers:
+```
+/var/run/docker.sock
+```
+
+For example, you can type the following when starting up a container:
+```
+docker run -v /var/run/docker.sock:/var/run/docker.sock [your-image-tag]
+```
+
+If you're using `docker-compose` to start up multiple containers, you can add a `volumes` key for each of your services in the `docker-compose.yml` file:
+
+```
+volumes:
+  - "/var/run/docker.sock:/var/run/docker.sock"
+```
+
+## Notifications
+
+The `notifications` property is optional and allows developers to be alerted when the server responds to requests with status codes >= 400. To set up notifications, set the value of the `notifications` property to an array of objects, each with a `type` and `settings` property. 
+
+Chronos only supports **Slack** and **email** notifications.
+<br>
+
+### Slack
+
+Chronos uses the <a href="#"><img src="./app/assets/slack-logo-color.png" alt="Slack" title="Slack" align="center" height="20" /></a> API to send messages to a Slack channel and only requires the **webhook url**. Learn how to set up [Slack webhooks](https://api.slack.com/messaging/webhooks) for your team.
+
+An example of configured **slack** settings:
+
+```js
+// ...
+notifications: [
+  {
+    type: 'email',
+    settings: {
+      slackurl: process.env.WEBHOOK
+    }
+  }
+]
+// ...
+```
+
+### Email
+Chronos provides the option to send <a href="#"><img src="./app/assets/email-icon-black.png" alt="Slack" title="Slack" align="center" height="20" /></a> emails. The properties that should be provided are the following
+- `emails` - The recipient list (string) can be a single email address or multiple as comma seprated values. 
+- `emailHost` - The smtp host (string) of your email server
+- `emailPort` - The email port (integer) is either **465** or **587** depending on the sender email security settings. Learn more about email ports by reading the [nodemailer docs](https://nodemailer.com/smtp/)
+- `user` - The email address (string) of the sender
+- `password` - The password (string) of the sender email
+
+_NOTE: Email notification settings may require alternative security settings to work_
+ 
+An example of configured **email** settings:
+
+```js
+// ...
+notifications: [
+  {
+    type: 'email',
+    settings: {
+      emails: '[email protected], [email protected]',
+      emailHost: '[email protected]',
+      emailPort: 465,
+      user: process.env.SENDER_EMAIL,
+      password: process.env.SENDER_PASSWORD
+    }
+  }
+]
+// ...
+```
+#
+###### Return to [Top](#chronos)
+<br>