cat-a-logs 2.0.0

package/.babelrc

@@ -0,0 +1,13 @@
+{
+    "presets": [
+      "@babel/preset-env",
+      [
+        "@babel/preset-react",
+        {
+          "runtime": "automatic" // allows use of JSX w/out import React from "react" in every component file - BMA
+        }
+      ]
+    ],
+    "plugins": ["@babel/plugin-transform-runtime"]
+  }
+  

package/README.md

@@ -0,0 +1,57 @@
+# cat-a-log
+This function will help you create AWS Embedded Metric Format Logs and publish them to AWS Cloudwatch. EMF formatting will allow for chosen metrics to be automatically visualized in graphs for simplier debugging.
+
+**What is Embedded Metric Formatting (EMF):**\
+This is a JSON specification to communicate with Cloudwatch Logs to automatically extract values embedded in the structured log events.
+EMF is especially great for applications that make logs and need custom metrics without more complexity or cost.
+ For more information please visit the link below 
+
+<a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Specification.html" target="_blank">AWS Documentation on EMF Formatting</a>
+
+
+**Why use cat-a-log?:**\
+Why use a washing machine when you can do them by hand? Becuase it makes your job way easier! Leveraging AWS Lambda Powertools we can use the cat-a-log function to invoke and format logs into AWS Embedded Metric Format. By publishing these logs to AWS Cloudwatch, we are able to provide engineers with automatic metric visulaization to make the process of debugging logs much more efficient. Cat-a-log utilizies a cache to make effcient work of sending logs to Cloudwatch.
+
+
+**How do I use cat-a-log?:**\
+npm install  our package using the command `npm install cat-a-logs` into your app.mjs file then capture the function and cache (we will talk about this later) 
+`import {cache, catalog} from "cat-a-logs/index.js";`
+
+The catalog function  below takes in the following arguments - lets look at each argument one at a time:
+
+`function catalog(
+  trackedVariable: number | Array<number>,
+  metricName: string,
+  metricNamespace: string,
+  metricUnitLabel: string = "None",
+  CustomerDefinedDimension: { [key: string]: string } = {},
+  resolution: 1 | 60 = 60,
+  deploy: boolean = false
+)`
+
+- **trackedVariable**: This is a number that is dynamic and can change with each call - these numbers are reflected 
+- **metricName**:
+- **metricNamespace**:
+- **metricUnitLabel**: Can only be the following labels:
+- Seconds | Microseconds | Milliseconds | Bytes | Kilobytes | Megabytes | Gigabytes | Terabytes | Bits | Kilobits | Megabits | Gigabits | Terabits | Percent | Count | Bytes/Second | Kilobytes/Second | Megabytes/Second | Gigabytes/Second | Terabytes/Second | Bits/Second | Kilobits/Second | Megabits/Second | Gigabits/Second | Terabits/Second | Count/Second | None\
+
+To read more about Metric Datum see this <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html" target="_blank">link</a>
+- **CustomerDefinedDimension**: 
+- **resolution**: 
+- **deploy**: 
+
+**Structure of the files:**\
+<a href="https://www.npmjs.com/package/cat-a-logs?activeTab=readme" target="_blank">Link to npm package</a>
+
+`index.ts` is compiled to `index.js`. Important to compile `.ts` file to es6 js syntax using the `tsc —target es6 (filepath)` command
+`app.mjs ` is a "pathway" to our lambda function. Here is where we will import catalog function and use it to involke our lambda function
+
+index.ts lines 25-30 is checking to see if the value "level" || "message" || "sampling_rate" || "service" || "timestamp" ||"xray_trace_id"
+
+logger.info gives you some information level is key and value is info
+
+
+if you write name that it will overwrite the keys 
+
+**Tech Challenges**
+Spent 3 days dealing with inconsistencies of ES6/CommonJS in our code before compiling .js in ES6

package/bin/catalogExe.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node;  
+//Above (UNIX - shebang) used to indicate this is an executable file that will use node as its interpreter
+
+

package/client/App.js

@@ -0,0 +1 @@
+"use strict";

package/client/css/input.css

@@ -0,0 +1,3 @@
+/* @tailwind base;
+@tailwind components;
+@tailwind utilities; */

package/client/index.js

@@ -0,0 +1,261 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Logger } from "@aws-lambda-powertools/logger";
+import { Ajv } from "ajv";
+//cache entries are structured thusly: 'Namespace + Dimensions(Alphabetically)': EMFObject
+const cache = {};
+//catalog(kilos, "kilos" , "lambda-function-metrics", "Kilograms", {'functionVersion': $LATEST, 'testDimension': derp});
+function catalog(trackedVariable_1, metricName_1, metricNamespace_1) {
+    return __awaiter(this, arguments, void 0, function* (trackedVariable, metricName, metricNamespace, metricUnitLabel = "None", CustomerDefinedDimension = {}, resolution = 60, deploy = false) {
+        //Check for any errors & validate inputs based on documentations
+        if (!cache)
+            throw new Error("cache is not found, please import cache from cat-a-log");
+        console.log(Object.keys(CustomerDefinedDimension).concat([metricName.toLowerCase()]));
+        const badKeys = ["level", "message", "sampling_rate", "service", "timestamp", "xray_trace_id"];
+        const yourKeys = Object.keys(CustomerDefinedDimension).concat([metricName.toLowerCase()]);
+        for (let i = 0; i < yourKeys.length; i++) {
+            if (badKeys.includes(yourKeys[i])) {
+                throw new Error("metricName, or Dimension names cannot be the same as these native logger keys: level || message || sampling_rate || service || timestamp || xray_trace_id");
+            }
+        }
+        if (Array.isArray(trackedVariable)) {
+            if (trackedVariable.length > 100)
+                throw new Error("metric value cannot have more than 100 elements");
+        }
+        if (Object.keys(CustomerDefinedDimension).length > 30) {
+            throw new Error("EMF has a limit of 30 user defined dimension keys per log");
+        }
+        const logger = new Logger({ serviceName: "serverlessAirline" });
+        // Ajv instance
+        const ajv = new Ajv();
+        // from AWS: EMF schema to test/validate against
+        const emfSchema = {
+            type: "object",
+            title: "Root Node",
+            required: ["_aws"],
+            properties: {
+                _aws: {
+                    $id: "#/properties/_aws",
+                    type: "object",
+                    title: "Metadata",
+                    required: ["Timestamp", "CloudWatchMetrics"],
+                    properties: {
+                        Timestamp: {
+                            $id: "#/properties/_aws/properties/Timestamp",
+                            type: "integer",
+                            title: "The Timestamp Schema",
+                            examples: [1565375354953],
+                        },
+                        CloudWatchMetrics: {
+                            $id: "#/properties/_aws/properties/CloudWatchMetrics",
+                            type: "array",
+                            title: "MetricDirectives",
+                            items: {
+                                $id: "#/properties/_aws/properties/CloudWatchMetrics/items",
+                                type: "object",
+                                title: "MetricDirective",
+                                required: ["Namespace", "Dimensions", "Metrics"],
+                                properties: {
+                                    Namespace: {
+                                        $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Namespace",
+                                        type: "string",
+                                        title: "CloudWatch Metrics Namespace",
+                                        examples: ["MyApp"],
+                                        pattern: "^(.*)$",
+                                        minLength: 1,
+                                        maxLength: 1024,
+                                    },
+                                    Dimensions: {
+                                        $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Dimensions",
+                                        type: "array",
+                                        title: "The Dimensions Schema",
+                                        minItems: 1,
+                                        items: {
+                                            $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Dimensions/items",
+                                            type: "array",
+                                            title: "DimensionSet",
+                                            minItems: 0,
+                                            maxItems: 30,
+                                            items: {
+                                                $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Dimensions/items/items",
+                                                type: "string",
+                                                title: "DimensionReference",
+                                                examples: ["Operation"],
+                                                pattern: "^(.*)$",
+                                                minLength: 1,
+                                                maxLength: 250,
+                                            },
+                                        },
+                                    },
+                                    Metrics: {
+                                        $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics",
+                                        type: "array",
+                                        title: "MetricDefinitions",
+                                        items: {
+                                            $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items",
+                                            type: "object",
+                                            title: "MetricDefinition",
+                                            required: ["Name"],
+                                            properties: {
+                                                Name: {
+                                                    $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items/properties/Name",
+                                                    type: "string",
+                                                    title: "MetricName",
+                                                    examples: ["ProcessingLatency"],
+                                                    pattern: "^(.*)$",
+                                                    minLength: 1,
+                                                    maxLength: 1024,
+                                                },
+                                                Unit: {
+                                                    $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items/properties/Unit",
+                                                    type: "string",
+                                                    title: "MetricUnit",
+                                                    examples: ["Milliseconds"],
+                                                    pattern: "^(Seconds|Microseconds|Milliseconds|Bytes|Kilobytes|Megabytes|Gigabytes|Terabytes|Bits|Kilobits|Megabits|Gigabits|Terabits|Percent|Count|Bytes\\/Second|Kilobytes\\/Second|Megabytes\\/Second|Gigabytes\\/Second|Terabytes\\/Second|Bits\\/Second|Kilobits\\/Second|Megabits\\/Second|Gigabits\\/Second|Terabits\\/Second|Count\\/Second|None)$",
+                                                },
+                                                StorageResolution: {
+                                                    $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items/properties/StorageResolution",
+                                                    type: "integer",
+                                                    title: "StorageResolution",
+                                                    examples: [60],
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const validateEmf = ajv.compile(emfSchema);
+        //sort customerDimensions key values in alphabetical order
+        const sortedDimensions = {};
+        for (let i = 0; i < Object.keys(CustomerDefinedDimension).sort().length; i++) {
+            sortedDimensions[Object.keys(CustomerDefinedDimension).sort()[i]] =
+                CustomerDefinedDimension[Object.keys(CustomerDefinedDimension).sort()[i]];
+        }
+        //if Object with Namespace and Dimensions already exists in Set
+        let check = cache[`${metricNamespace}${sortedDimensions}`];
+        if (check != undefined) {
+            //push the metrics object to Metrics array
+            cache[`${metricNamespace}${sortedDimensions}`]["_aws"]["CloudWatchMetrics"][0]["Metrics"].push({
+                Name: metricName,
+                Unit: metricUnitLabel,
+                StorageResolution: resolution,
+            });
+            //add key value to Log
+            check[`${metricName}`] = trackedVariable;
+        }
+        else {
+            // //create new Structured Log and add it to cachedStructuredLogs  - BMA 1/18/25 removed to test Ajv
+            // cache[`${metricNamespace}${sortedDimensions}`] = Object.assign(
+            // NameSpace & Dimensions for EMF part don't exist yet.  Initialize variable to capture EMF/aws key:value pair
+            const newEmfLog = Object.assign({
+                _aws: {
+                    Timestamp: Date.now(),
+                    CloudWatchMetrics: [
+                        {
+                            Namespace: metricNamespace,
+                            Dimensions: [Object.keys(sortedDimensions)],
+                            Metrics: [
+                                {
+                                    Name: metricName,
+                                    Unit: metricUnitLabel,
+                                    StorageResolution: resolution,
+                                },
+                            ],
+                        },
+                    ],
+                },
+                [`${metricName}`]: trackedVariable,
+            }, CustomerDefinedDimension);
+            // Log the Unit value before validation
+            console.log("index.ts - Unit value before validation: ", newEmfLog._aws.CloudWatchMetrics[0].Metrics[0].Unit);
+            // validate the new EMF JSON schema against AWS EMF JSON schema before adding to cache object
+            const isValid = validateEmf(newEmfLog);
+            // //troubleshooting console.error in test
+            // console.log('index.ts - Validation result: ', isValid);
+            // troubleshooting console.error in emf test
+            // console.log('index.ts - Validation errors: ', validateEmf.errors);
+            // if it fails validation throw error
+            if (!isValid) {
+                console.error("An error occurred during EMF validation: ", validateEmf.errors);
+                throw new Error("Supplied/Proposed structured log does not comply with EMF schema");
+            }
+            // If it passes then add to cache object
+            cache[`${metricNamespace}${sortedDimensions}`] = newEmfLog;
+        }
+        if (deploy) {
+            //after last catalog function is invoked, send all cached logs with logger at once
+            for (let i = 0; i < Object.keys(cache).length; i++) {
+                logger.info(`Your EMF compliant Structured Metrics Log ${i + 1}`, cache[Object.keys(cache)[i]]);
+            }
+            //clear cache
+            console.log("BEFORE:", cache);
+            for (var member in cache)
+                delete cache[member];
+            console.log("AFTER:", cache);
+        }
+    });
+}
+export { cache, catalog };
+/*Current Working logger invocation
+logger.info("Your EMF compliant Structured Metrics Log",
+  Object.assign({
+    _aws: {
+      Timestamp: Date.now(),
+      CloudWatchMetrics: [
+        {
+          Namespace: metricNamespace,
+          Dimensions: [Object.keys(CustomerDefinedDimension)],
+          Metrics: [
+            {
+              Name: metricName,
+              Unit: metricUnitLabel,
+              StorageResolution: resolution,
+            }
+          ]
+        }
+      ]
+    },
+    [`${metricName}`]: trackedVariable,
+    },
+      CustomerDefinedDimension
+    )
+  
+)
+*/
+//Old handler function
+// export const handler = async (_event, _context): Promise<void> => {
+//   const testObj = {
+//     testguy: "hi",
+//     fool: 42,
+//     functionVersion: "$LATEST",
+//     _aws: {
+//       Timestamp: Date.now(),
+//       CloudWatchMetrics: [
+//         {
+//           Namespace: "lambda-function-metrics",
+//           Dimensions: [["functionVersion"]],
+//           Metrics: [
+//             {
+//               Name: "fool",
+//               Unit: "Milliseconds",
+//               StorageResolution: 60
+//             }
+//           ]
+//         }
+//       ]
+//     },
+//   }
+//   logger.info(JSON.stringify(testObj));
+// };

package/client/index.ts

@@ -0,0 +1,291 @@
+import { Logger } from "@aws-lambda-powertools/logger";
+import { Ajv } from "ajv";
+
+//cache entries are structured thusly: 'Namespace + Dimensions(Alphabetically)': EMFObject
+const cache: { [key: string]: any } = {};
+//catalog(kilos, "kilos" , "lambda-function-metrics", "Kilograms", {'functionVersion': $LATEST, 'testDimension': derp});
+async function catalog(
+  trackedVariable: number | Array<number>,
+  metricName: string,
+  metricNamespace: string,
+  metricUnitLabel: string = "None",
+  CustomerDefinedDimension: { [key: string]: string } = {},
+  resolution: 1 | 60 = 60,
+  deploy: boolean = false
+): Promise<void> {
+  //Check for any errors & validate inputs based on documentations
+  if (!cache)
+    throw new Error("cache is not found, please import cache from cat-a-log");
+  console.log(Object.keys(CustomerDefinedDimension).concat([metricName.toLowerCase()]));
+  const badKeys = ["level", "message", "sampling_rate", "service", "timestamp", "xray_trace_id"];
+  const yourKeys = Object.keys(CustomerDefinedDimension).concat([metricName.toLowerCase()]);
+  for(let i = 0; i < yourKeys.length; i++){
+    if(badKeys.includes(yourKeys[i])){
+      throw new Error(
+        "metricName, or Dimension names cannot be the same as these native logger keys: level || message || sampling_rate || service || timestamp || xray_trace_id"
+      );
+    }
+  }
+    
+  
+    
+  if (Array.isArray(trackedVariable)) {
+    if (trackedVariable.length > 100)
+      throw new Error("metric value cannot have more than 100 elements");
+  }
+  if (Object.keys(CustomerDefinedDimension).length > 30) {
+    throw new Error(
+      "EMF has a limit of 30 user defined dimension keys per log"
+    );
+  }
+  const logger = new Logger({ serviceName: "serverlessAirline" });
+  // Ajv instance
+  const ajv = new Ajv();
+  // from AWS: EMF schema to test/validate against
+  const emfSchema = {
+    type: "object",
+    title: "Root Node",
+    required: ["_aws"],
+    properties: {
+      _aws: {
+        $id: "#/properties/_aws",
+        type: "object",
+        title: "Metadata",
+        required: ["Timestamp", "CloudWatchMetrics"],
+        properties: {
+          Timestamp: {
+            $id: "#/properties/_aws/properties/Timestamp",
+            type: "integer",
+            title: "The Timestamp Schema",
+            examples: [1565375354953],
+          },
+          CloudWatchMetrics: {
+            $id: "#/properties/_aws/properties/CloudWatchMetrics",
+            type: "array",
+            title: "MetricDirectives",
+            items: {
+              $id: "#/properties/_aws/properties/CloudWatchMetrics/items",
+              type: "object",
+              title: "MetricDirective",
+              required: ["Namespace", "Dimensions", "Metrics"],
+              properties: {
+                Namespace: {
+                  $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Namespace",
+                  type: "string",
+                  title: "CloudWatch Metrics Namespace",
+                  examples: ["MyApp"],
+                  pattern: "^(.*)$",
+                  minLength: 1,
+                  maxLength: 1024,
+                },
+                Dimensions: {
+                  $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Dimensions",
+                  type: "array",
+                  title: "The Dimensions Schema",
+                  minItems: 1,
+                  items: {
+                    $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Dimensions/items",
+                    type: "array",
+                    title: "DimensionSet",
+                    minItems: 0,
+                    maxItems: 30,
+                    items: {
+                      $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Dimensions/items/items",
+                      type: "string",
+                      title: "DimensionReference",
+                      examples: ["Operation"],
+                      pattern: "^(.*)$",
+                      minLength: 1,
+                      maxLength: 250,
+                    },
+                  },
+                },
+                Metrics: {
+                  $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics",
+                  type: "array",
+                  title: "MetricDefinitions",
+                  items: {
+                    $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items",
+                    type: "object",
+                    title: "MetricDefinition",
+                    required: ["Name"],
+                    properties: {
+                      Name: {
+                        $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items/properties/Name",
+                        type: "string",
+                        title: "MetricName",
+                        examples: ["ProcessingLatency"],
+                        pattern: "^(.*)$",
+                        minLength: 1,
+                        maxLength: 1024,
+                      },
+                      Unit: {
+                        $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items/properties/Unit",
+                        type: "string",
+                        title: "MetricUnit",
+                        examples: ["Milliseconds"],
+                        pattern:
+                          "^(Seconds|Microseconds|Milliseconds|Bytes|Kilobytes|Megabytes|Gigabytes|Terabytes|Bits|Kilobits|Megabits|Gigabits|Terabits|Percent|Count|Bytes\\/Second|Kilobytes\\/Second|Megabytes\\/Second|Gigabytes\\/Second|Terabytes\\/Second|Bits\\/Second|Kilobits\\/Second|Megabits\\/Second|Gigabits\\/Second|Terabits\\/Second|Count\\/Second|None)$",
+                      },
+                      StorageResolution: {
+                        $id: "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items/properties/StorageResolution",
+                        type: "integer",
+                        title: "StorageResolution",
+                        examples: [60],
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const validateEmf = ajv.compile(emfSchema);
+  //sort customerDimensions key values in alphabetical order
+  const sortedDimensions: { [key: string]: string } = {};
+  for (
+    let i = 0;
+    i < Object.keys(CustomerDefinedDimension).sort().length;
+    i++
+  ) {
+    sortedDimensions[Object.keys(CustomerDefinedDimension).sort()[i]] =
+      CustomerDefinedDimension[Object.keys(CustomerDefinedDimension).sort()[i]];
+  }
+  //if Object with Namespace and Dimensions already exists in Set
+  let check = cache[`${metricNamespace}${sortedDimensions}`];
+  if (check != undefined) {
+    //push the metrics object to Metrics array
+    cache[`${metricNamespace}${sortedDimensions}`]["_aws"][
+      "CloudWatchMetrics"
+    ][0]["Metrics"].push({
+      Name: metricName,
+      Unit: metricUnitLabel,
+      StorageResolution: resolution,
+    });
+    //add key value to Log
+    check[`${metricName}`] = trackedVariable;
+  } else {
+    // //create new Structured Log and add it to cachedStructuredLogs  - BMA 1/18/25 removed to test Ajv
+    // cache[`${metricNamespace}${sortedDimensions}`] = Object.assign(
+    // NameSpace & Dimensions for EMF part don't exist yet.  Initialize variable to capture EMF/aws key:value pair
+    const newEmfLog = Object.assign(
+      {
+        _aws: {
+          Timestamp: Date.now(),
+          CloudWatchMetrics: [
+            {
+              Namespace: metricNamespace,
+              Dimensions: [Object.keys(sortedDimensions)],
+              Metrics: [
+                {
+                  Name: metricName,
+                  Unit: metricUnitLabel,
+                  StorageResolution: resolution,
+                },
+              ],
+            },
+          ],
+        },
+        [`${metricName}`]: trackedVariable,
+      },
+      CustomerDefinedDimension
+    );
+
+    // Log the Unit value before validation
+    console.log(
+      "index.ts - Unit value before validation: ",
+      newEmfLog._aws.CloudWatchMetrics[0].Metrics[0].Unit
+    );
+
+    // validate the new EMF JSON schema against AWS EMF JSON schema before adding to cache object
+    const isValid = validateEmf(newEmfLog);
+    // //troubleshooting console.error in test
+    // console.log('index.ts - Validation result: ', isValid);
+    // troubleshooting console.error in emf test
+    // console.log('index.ts - Validation errors: ', validateEmf.errors);
+    // if it fails validation throw error
+    if (!isValid) {
+      console.error(
+        "An error occurred during EMF validation: ",
+        validateEmf.errors
+      );
+      throw new Error(
+        "Supplied/Proposed structured log does not comply with EMF schema"
+      );
+    }
+    // If it passes then add to cache object
+    cache[`${metricNamespace}${sortedDimensions}`] = newEmfLog;
+  }
+
+  if (deploy) {
+    //after last catalog function is invoked, send all cached logs with logger at once
+    for (let i = 0; i < Object.keys(cache).length; i++) {
+      logger.info(
+        `Your EMF compliant Structured Metrics Log ${i + 1}`,
+        cache[Object.keys(cache)[i]]
+      );
+    }
+    //clear cache
+    console.log("BEFORE:", cache);
+    for (var member in cache) delete cache[member];
+    console.log("AFTER:", cache);
+  }
+}
+export { cache, catalog };
+
+/*Current Working logger invocation
+logger.info("Your EMF compliant Structured Metrics Log",
+  Object.assign({
+    _aws: {
+      Timestamp: Date.now(),
+      CloudWatchMetrics: [
+        {
+          Namespace: metricNamespace,
+          Dimensions: [Object.keys(CustomerDefinedDimension)],
+          Metrics: [
+            {
+              Name: metricName,
+              Unit: metricUnitLabel,
+              StorageResolution: resolution,
+            }
+          ]
+        }
+      ]
+    },
+    [`${metricName}`]: trackedVariable,
+    }, 
+      CustomerDefinedDimension
+    )
+  
+)
+*/
+
+//Old handler function
+// export const handler = async (_event, _context): Promise<void> => {
+//   const testObj = {
+//     testguy: "hi",
+//     fool: 42,
+//     functionVersion: "$LATEST",
+//     _aws: {
+//       Timestamp: Date.now(),
+//       CloudWatchMetrics: [
+//         {
+//           Namespace: "lambda-function-metrics",
+//           Dimensions: [["functionVersion"]],
+//           Metrics: [
+//             {
+//               Name: "fool",
+//               Unit: "Milliseconds",
+//               StorageResolution: 60
+//             }
+//           ]
+//         }
+//       ]
+//     },
+//   }
+//   logger.info(JSON.stringify(testObj));
+// };

package/client/template.html

@@ -0,0 +1,18 @@
+<!-- Used by HTMLWebpackPlugin (per plugins config in webpack.config.js)
+  to build index.html with each webpack rebuild/rebundle -->
+
+  <!DOCTYPE html>
+  <html>
+    <head>
+      <meta charset="utf-8" />
+      <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+      <title>%= htmlWebpackPlugin.options.title %</title>
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+    </head>
+    <body>
+        <h1 class="text-4xl text-blue-700">My Webpack + Tailwind App</h1>
+        <script src="dist/bundle.js"></script>
+      <!-- Insert React App here -->
+      <div id="root"></div>
+    </body>
+  </html>