feat(metrics): Completed metricsserver.

Author: kleinschrader

CMakeLists.txt

@@ -26,7 +26,9 @@ SET(libsrc
 ./source/sslConnection/sslConnection.cpp
 ./source/metricsServer/metricsServer.cpp
 ./source/metricBase/metricBase.cpp
-./source/counterMetric/counterMetric.cpp)
+./source/counterMetric/counterMetric.cpp
+./source/histogramMetric/histogramMetric.cpp
+./source/gaugeMetric/gaugeMetric.cpp)
 
 SET(libhead
 ./source/socketBase/socketBase.h
@@ -42,6 +44,8 @@ SET(libhead
 ./source/metricsServer/metricsServer.h
 ./source/metricBase/metricBase.h
 ./source/counterMetric/counterMetric.h
+./source/histogramMetric/histogramMetric.h
+./source/gaugeMetric/gaugeMetric.h
 ./source/templates.h)
 
 ADD_LIBRARY(kleinsHTTP-shared SHARED "${libsrc}")

examples/simpleHelloWorld/main.cpp

@@ -1,17 +1,18 @@
 #include "../../libkleinsHTTP.h"
 
-int main(){
-    kleins::httpServer server;
+int main() {
+  kleins::httpServer server;
+  server.startMetricsServer(9090);
 
-    server.printVersion();
+  server.printVersion();
 
-    server.addSocket(new kleins::tcpSocket("0.0.0.0",8080));
+  server.addSocket(new kleins::tcpSocket("0.0.0.0", 8080));
 
-    server.on(kleins::httpMethod::GET,"/",[](kleins::httpParser* data){
-        data->respond("200",{},"Hello!");
-    });
+  server.on(kleins::httpMethod::GET, "/", [](kleins::httpParser* data) { data->respond("200", {}, "Hello!"); });
 
-    for(;;) {
-        usleep(90000);
-    }
+  server.on(kleins::httpMethod::GET, "/hi", [](kleins::httpParser* data) { data->respond("200", {}, "Hi!"); });
+
+  for (;;) {
+    usleep(90000);
+  }
 }

preheader.h

@@ -1,6 +1,13 @@
 #define SINGLE_HEADER
 
 namespace kleins {
+    namespace metrics {
+        class metricBase;
+        class counterMetric;
+        class histogramMetric;
+        class gaugeMetric;
+        class metricServer;
+    };
     class packet;
     class connectionBase;
     class tcpConnection;

source/counterMetric/counterMetric.cpp

@@ -1,40 +1,39 @@
 #include "counterMetric.h"
 
-
-kleins::metrics::counterMetric::counterMetric(/* args */)
-{
+kleins::metrics::counterMetric::counterMetric(const char* name, const char* help) {
+  setName(name);
+  setHelp(help);
 }
 
-kleins::metrics::counterMetric::~counterMetric()
-{
+kleins::metrics::counterMetric::~counterMetric() {
 }
 
 const char* kleins::metrics::counterMetric::getType() {
-    return "counter";
+  return "counter";
 }
 
 std::unique_ptr<char*> kleins::metrics::counterMetric::construct() {
-    char* targetBuffer = new char[4096];
+  char* targetBuffer = new char[4096];
 
-    snprintf(targetBuffer,4096,"# HELP %s %s\r\n# TYPE %s %s\r\n%s %i",nameString, helpString, nameString, getType(), nameString, counterValue);
+  snprintf(targetBuffer, 4096, "# HELP %s %s\r\n# TYPE %s %s\r\n%s %i\r\n", nameString, helpString, nameString, getType(), nameString, counterValue);
 
-    return std::make_unique<char*>(targetBuffer);
+  return std::make_unique<char*>(targetBuffer);
 };
 
 uint64_t kleins::metrics::counterMetric::get() {
-    return counterValue;
+  return counterValue;
 }
 
-void kleins::metrics::counterMetric::set(uint64_t value){
-    assert(("Attemped to decrease counter value",value<counterValue));
+void kleins::metrics::counterMetric::set(uint64_t value) {
+  assert(("Attemped to decrease counter value", value < counterValue));
 
-    counterValue = value;
+  counterValue = value;
 }
 
-void kleins::metrics::counterMetric::inc(uint64_t value = 1){
-    counterValue += value;
+void kleins::metrics::counterMetric::inc(uint64_t value) {
+  counterValue += value;
 }
 
 void kleins::metrics::counterMetric::reset() {
-    counterValue = 0;
+  counterValue = 0;
 }

source/counterMetric/counterMetric.h

@@ -1,8 +1,8 @@
 #ifndef COUNTERMETRIC_H
 #define COUNTERMETRIC_H
 
-#include <stdio.h>
 #include <cassert>
+#include <stdio.h>
 
 #ifndef SINGLE_HEADER
 #include "../metricBase/metricBase.h"
@@ -12,27 +12,25 @@ namespace kleins {
 
 namespace metrics {
 
-class counterMetric : public metricBase
-{
+class counterMetric : public metricBase {
 private:
-    uint64_t counterValue = 0;
+  uint64_t counterValue = 0;
+
 public:
-    counterMetric(/* args */);
-    ~counterMetric();
+  counterMetric(const char* name, const char* help);
+  ~counterMetric();
 
-    uint64_t get();
-    void set(uint64_t value);
-    void inc(uint64_t value = 1);
-    void reset();
+  uint64_t get();
+  void set(uint64_t value);
+  void inc(uint64_t value = 1);
+  void reset();
 
-    virtual const char* getType();
+  virtual const char* getType();
 
-    virtual std::unique_ptr<char*> construct() = 0;
+  virtual std::unique_ptr<char*> construct();
 };
 
-
-
-}
+} // namespace metrics
 
 } // namespace kleins
 

source/gaugeMetric/gaugeMetric.cpp

@@ -0,0 +1,29 @@
+#include "gaugeMetric.h"
+
+kleins::metrics::gaugeMetric::gaugeMetric(const char* name, const char* help) {
+  setName(name);
+  setHelp(help);
+}
+
+kleins::metrics::gaugeMetric::~gaugeMetric() {
+}
+
+const char* kleins::metrics::gaugeMetric::getType() {
+  return "gauge";
+}
+
+std::unique_ptr<char*> kleins::metrics::gaugeMetric::construct() {
+  char* targetBuffer = new char[4096];
+
+  snprintf(targetBuffer, 4096, "# HELP %s %s\r\n# TYPE %s %s\r\n%s %i\r\n", nameString, helpString, nameString, getType(), nameString, counterValue);
+
+  return std::make_unique<char*>(targetBuffer);
+};
+
+uint64_t kleins::metrics::gaugeMetric::get() {
+  return counterValue;
+}
+
+void kleins::metrics::gaugeMetric::set(uint64_t value) {
+  counterValue = value;
+}

source/gaugeMetric/gaugeMetric.h

@@ -0,0 +1,35 @@
+#ifndef GAUGEMETRIC_H
+#define GAUGEMETRIC_H
+
+#include <cassert>
+#include <stdio.h>
+
+#ifndef SINGLE_HEADER
+#include "../metricBase/metricBase.h"
+#endif
+
+namespace kleins {
+
+namespace metrics {
+
+class gaugeMetric : public metricBase {
+private:
+  uint64_t counterValue = 0;
+
+public:
+  gaugeMetric(const char* name, const char* help);
+  ~gaugeMetric();
+
+  uint64_t get();
+  void set(uint64_t value);
+
+  virtual const char* getType();
+
+  virtual std::unique_ptr<char*> construct();
+};
+
+} // namespace metrics
+
+} // namespace kleins
+
+#endif

source/histogramMetric/histogramMetric.cpp

@@ -0,0 +1,71 @@
+#include "histogramMetric.h"
+
+uint64_t kleins::metrics::counterBucketMetricData::get() {
+  return counterValue;
+}
+
+void kleins::metrics::counterBucketMetricData::set(uint64_t value) {
+  assert(("Attemped to decrease counter value", value < counterValue));
+
+  counterValue = value;
+}
+
+void kleins::metrics::counterBucketMetricData::inc(uint64_t value) {
+  counterValue += value;
+}
+
+void kleins::metrics::counterBucketMetricData::reset() {
+  counterValue = 0;
+}
+
+kleins::metrics::histogramMetric::histogramMetric(const char* name, const char* help) {
+  setName(name);
+  setHelp(help);
+}
+
+kleins::metrics::histogramMetric::~histogramMetric() {
+}
+
+const char* kleins::metrics::histogramMetric::getType() {
+  return "counter";
+}
+
+void kleins::metrics::histogramMetric::addBucket(const char* bucketName) {
+  counterValues.insert(std::make_pair(std::string(bucketName), new counterBucketMetricData));
+}
+
+kleins::metrics::counterBucketMetricData* kleins::metrics::histogramMetric::operator[](std::string& input) {
+  for (auto x : counterValues) {
+    if (x.first == input) {
+      return x.second;
+    }
+  }
+  assert("A Bucket was accessed that never existed");
+  return 0;
+}
+
+kleins::metrics::counterBucketMetricData* kleins::metrics::histogramMetric::operator[](const char* input) {
+  for (auto x : counterValues) {
+    if (x.first == input) {
+      return x.second;
+    }
+  }
+  assert("A Bucket was accessed that never existed");
+  return 0;
+}
+
+std::unique_ptr<char*> kleins::metrics::histogramMetric::construct() {
+  std::stringstream ss;
+  ss << "# HELP " << nameString << ' ' << helpString << "\r\n"
+     << "# TYPE " << nameString << ' ' << getType() << "\r\n";
+
+  for (auto x : counterValues) {
+    ss << nameString << '{' << x.first << "} " << x.second->get() << "\r\n";
+  }
+  int totalLength = ss.str().length();
+
+  char* outputBuffer = new char[totalLength];
+  std::memcpy(outputBuffer, ss.str().c_str(), totalLength);
+
+  return std::make_unique<char*>(outputBuffer);
+};

source/histogramMetric/histogramMetric.h

@@ -0,0 +1,52 @@
+#ifndef HISTOGRAMMETRIC_H
+#define HISTOGRAMMETRIC_H
+
+#include <cassert>
+#include <cstring>
+#include <map>
+#include <sstream>
+#include <stdio.h>
+#include <string>
+
+#ifndef SINGLE_HEADER
+#include "../metricBase/metricBase.h"
+#endif
+
+namespace kleins {
+
+namespace metrics {
+
+class counterBucketMetricData {
+private:
+  uint64_t counterValue = 0;
+
+public:
+  uint64_t get();
+  void set(uint64_t value);
+  void inc(uint64_t value = 1);
+  void reset();
+};
+
+class histogramMetric : public metricBase {
+private:
+  std::map<std::string, counterBucketMetricData*> counterValues;
+
+public:
+  histogramMetric(const char* name, const char* help);
+  ~histogramMetric();
+
+  counterBucketMetricData* operator[](std::string& input);
+  counterBucketMetricData* operator[](const char* input);
+
+  void addBucket(const char* bucketName);
+
+  virtual const char* getType();
+
+  virtual std::unique_ptr<char*> construct();
+};
+
+} // namespace metrics
+
+} // namespace kleins
+
+#endif

source/httpParser/httpParser.cpp

@@ -71,11 +71,14 @@ bool kleins::httpParser::parse() {
   if (search != functionTable.end()) {
     search->second(this);
   } else {
+    if (server->metric_notfound) {
+      server->metric_notfound->inc();
+    }
     connsocket->sendData(
         "HTTP/1.0 404\r\ncontent-type:text/html; "
-        "charset=UTF-8\r\n\r\n<html><head></head><body>Not "
+        "charset=UTF-8\r\nContent-Length: 51\r\n\r\n<html><head></head><body>Not "
         "found</body></html>\r\n",
-        104);
+        127);
   }
 
   return true;