echo_cli 0.6.25 → 0.6.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf3652734735f3b562afe8c8036c6a0bee734280
-  data.tar.gz: 753163b93233f69e2d3001d1ad20daf3c5c4776a
+  metadata.gz: c3b600a594c6f6f3219bb052d8ca7f7705bc866c
+  data.tar.gz: 1d3ff7b2815f508e24f327d304dd873dc8dc8c68
 SHA512:
-  metadata.gz: 2a8ca42b69ef97783cc919d1c8859a40dd6abada247cc8667ddc4f434473b9369d12fdde523add83c662917b2be0083307638d3d80369bbb14b9246546504dc8
-  data.tar.gz: 4691ad7376667dcc69ddd2cb5f389b1c04f8817207a6d81ade8330a5e70ca32e51a04f0a160156e9165e19f4744c91ad8fff5394bcdf89aeb911eb44e041c98c
+  metadata.gz: aeac419f4164aabe7752a991c4ced877e8319fad765b188b06bc97a8e648fa8068b839124067fc11bdffd5bafe4adc90994d82a7a678972016a7ebec12894966
+  data.tar.gz: 5623cf94125413f9ab875a4609882ee2918a03d29fdf3a5ef56adecf09d46be4db4f7b028ca376f98ed7d2b89c0845b73aa127a1949bc1da1064c1147974d703

data/README.md

@@ -110,26 +110,6 @@ $ echo_cli convert 2017-05-11T15:05:23-07:00
 ```
 This example will convert from a human-readable timestamp to an epoch timestamp.
 
-#### cpost
-```bash
-$ echo_cli cpost '<metric>' {frequency} {-v} {-z}
-```
-Parameters:
-
-`'<metric>'`: (required) the application name, as well as any tags, and data value and data type to be posted to StatsD
-
-`{frequency}`: (optional) the rate at which the metric will be continuously posted to Echo's server. If left unspecified, this value will default to 10 seconds.
-
-`{-v}`: (optional) continuously output a 'successfully posted' message, with updated start and end times, to the command line.
-
-`{-z}`: (optional) spawn the continuous post process in the background. Additionally, this option will return a PID (Process ID) that can be used in the future to kill the command. Use `kill -9 <PID>` to kill the process.
-
-Example:
-```bash
-$ echo_cli cpost 'example.post:1|c' 5 -z
-```
-The previous example will post the metric 'example' with tag 'post' to Echo's StatsD server instance once every 5 seconds. The specified '-z' option will spawn the process in the background, and return the newly spawned process ID in the command line.
-
 #### help
 ```bash
 $ echo_cli help [COMMAND]
@@ -154,67 +134,43 @@ $ echo_cli now
 
 #### post
 ```bash
-$ echo_cli post '<metric>' {number} {-q} {-v}
+$ echo_cli post '<metric>' {number} {-z}
 ```
 Parameters:
 
-`'<metric>'`: (required) the application name, as well as any tags, and data value and data type to be posted to StatsD
+`'<metric>'`: (required) the application name, as well as any tags, and data value and data type to be posted to StatsD. Note the single-quotes surrounding the metric, these are required as well.
 
 `{number}`: (optional) the number of posts to occur, e.g. a number value of '10' would post the metric 10 times to the StatsD server
 
-`{-q}`: (optional) does an automatic query of OpenTSDB immediately following the successful post of the metric to ensure the data transfer between StatsD and OpenTSDB. This option requires approx. 15 seconds to complete, as data flush and HA require ~15 seconds to occur.
-
-`{-v}`: (optional) continuously output a 'successfully posted' message, with updated start and end times, to the command line.
+`{-z}`: (optional) spawn the continuous post process in the background. Additionally, this option will return a PID (Process ID) that can be used in the future to kill the command. Use `kill -9 <PID>` to kill the process.
 
 Example:
 ```bash
-$ echo_cli 'sample.post.here:1|c' 10 -q -v
+$ echo_cli 'sample.post.here:1|c' 10
 ```
-The previous example would post the application name 'sample' with tags 'post' and 'here' with data value '1' and with data type 'c' (for count). This information would be posted to the instance of StatsD, and it would be posted 10 times. Additionally, because of the '-q' specified option, OpenTSDB will be queried immediately after the post to StatsD, to verify it has been received by Echo's instance of OpenTSDB. The '-v' option will cause the CLI to continuously output a "Successfully posted" message each time a data point is sent.
+The previous example would post the application name 'sample' with tags 'post' and 'here' with data value '1' and with data type 'c' (for count). This information would be posted to the instance of StatsD, and it would be posted 10 times.
 
 #### query
 ```bash
-$ echo_cli query '<metric>' <time_start> <time_end> {-v} {-e} {-s}
+$ echo_cli query '<metric>' <time_start> <time_end>
 ```
 Parameters:
 
-`'<metric>'`: (required) the application name, including any tags, with which the query for OpenTSDB will be constructed
-
-`<time_start>`: (required) the start of the range you are attempting to query in seconds from January 1, 1970 (epoch time)
-
-`<time_end>`: (required) the end of the range you are attempting to query in seconds from January 1, 1970 (epoch time)
-
-`{-v}`: (optional) verbosely prints the status code and response body of the query
-
-`{-e}`: (optional) formats the response datapoints such that their timestamps are in the epoch format, must have '-v' option selected for changes to appear
-
-`{-s}`: (optional) formats the response datapoints to be usable as SQL statements for insertions into SQL-esque databases, must have '-v' option selected for changes to appear
-
-Example:
-```bash
-$ echo_cli query 'sample.query.here' 1492464745 1492465045 -v
-```
-The previous example will query OpenTSDB with the application name 'sample' and tags 'query' and 'here' between the times of '1492464745' and '1492465045'. Additionally, the '-v' specified option will also return the response code and response body upon completion.
-
-#### fquery
-```bash
-$ echo_cli fquery '<metric>' <range> {-e} {-s}
-```
-Parameters:
+`'<metric>'`: (required) the application name, including any tags, with which the query for Graphite will be constructed
 
-`'<metric>'`: (required) the application name, including any tags, with which the query for OpenTSDB will be constructed
+`{time_start}`: (optional) the start of the range you are attempting to query in seconds from January 1, 1970 (epoch time)
 
-`<range>`: (required) the time, in seconds, from the current time (epoch time) that you would like to query, e.g. a 'range' value of 300 would query OpenTSDB for the specified metric in the last 5 minutes of time-series data
+`{time_end}`: (optional) the end of the range you are attempting to query in seconds from January 1, 1970 (epoch time)
 
-`{-e}`: (optional) formats the response datapoints such that their timestamps are in the epoch format
+See: https://graphite-api.readthedocs.io/en/latest/api.html#from-until for possible time_start and time_end formats.
 
-`{-s}`: (optional) formats the response datapoints to be usable as SQL statements for insertions into SQL-esque databases
+The default timestamp query range begins 15 minutes prior to the current time, to now.
 
 Example:
 ```bash
-$ echo_cli fquery 'sample.query.here' 300 -s
+$ echo_cli query 'sample.query.here:1|c' 1492464745 1492465045
 ```
-The previous example will query OpenTSDB with the application name 'sample' and tags 'query' and 'here', within the time range spanning from the current time to '300' seconds before the current time. The '-s' option will return the data as SQL statements for later insertion into a SQL database.
+The previous example will query Graphite with the application name 'sample' and tags 'query' and 'here' between the times of '1492464745' and '1492465045'.
 
 ## Development
 

data/lib/echo_cli/cli.rb

@@ -2,19 +2,22 @@ require 'thor'
 require 'json'
 require 'time'
 require 'colorize'
+require 'socket'
 require 'net/http'
 require 'net/https'
 require 'uri'
 require 'openssl'
+require 'timeout'
 
 module Echo_cli
   class Echo < Thor
-    desc "post", "Post metrics to Echo. Use \"echo_cli post '<metric>' {number} {-q} {-v}\""
+    desc "post", "Post metrics to Echo. Use \"echo_cli post '<metric>' {number} {-z}\""
 
-    option :q
-    option :v
+    option :z
 
     long_desc <<-LONGDESC
+      Post metrics to Echo. Use \"echo_cli post '<metric>' {number} {-z}\"
+
       `echo_cli post` will post a metric directly to Echo's StatsD server.
 
       You can optionally specify a third integer parameter, which will post the same metric an integer number of times equal to the number specified.
@@ -23,365 +26,98 @@ module Echo_cli
 
       Ensure the environment variable 'ECHO_CLI_HOST' is set to the correct IP.
 
-      With -q (query-verify) option, post will perform a query of previously posted metric in Echo's instance of OpenTSDB, and provide a message verifying the datapoint exists.
+      With the -z (zombie) option, post will continuously send the metric to Echo once every second in the background, and return its PID for future removal. Use "$ kill -9 <PID>" to kill the zombie process.
 
-      With -v (verbose) option, post will continuously output a 'successfully posted' message, with updated times, to the command line, if the 'number' argument is specified.
+      The -z option will override the {number} parameter, should both be included in an execution of the command.
 
-      > $ echo_cli post 'example.post:1|c' {10} {-q} {-v}
+      > $ echo_cli post 'example.post:1|c' {10} {-z}
     LONGDESC
 
-    def post(metric, num = 0)
-      Helper.new.check_for_IP()
-      statsd_uri = "https://" + ENV["ECHO_CLI_HOST"] + ":8125/metrix"
-
-      Helper.new.set_envs()
-
-      uri = URI.parse(statsd_uri)
-      request = Net::HTTP::Post.new(uri)
-      request["Token"] = "mySecretToken"
-      request.body = metric.gsub(/'/,"")
-
-      req_options = {
-        use_ssl: uri.scheme == "https",
-        verify_mode: OpenSSL::SSL::VERIFY_NONE,
-      }
-
-      if(num.to_i > 0)
-        begin
-          time_start = Time.new.to_i.to_s
-
-          for i in 1..num.to_i
-            time_temp_start = Time.new.to_i.to_s
-
-            response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
-              http.request(request)
-            end
-
-            time_temp_end = Time.new.to_i.to_s
-
-            if response.code != '200'
-              puts "Final run at: " + i + " of " + num
-              raise
-            end
-            if(options[:v] && response.code == '200')
-              puts "\nSuccessfully posted ".green + request.body.yellow + " to ".green + statsd_uri.blue + "\nTime start: ".green + time_temp_start.yellow + ", Time end: ".green + time_temp_end.yellow + "\n"
-            end
-          end
-
-          if options[:q]
-            sleep 15 # ensure data reception and replication
-          end
-          time_end = Time.new.to_i.to_s
-
-          puts "\nSuccessfully posted ".green + request.body.yellow + " to ".green + statsd_uri.blue + " " + num.to_s.green + " time(s)".green + "\nTime start: ".green + time_start.yellow + ", Time end: ".green + time_end.yellow
-
-          if options[:q]
-            opentsdb_uri = statsd_uri[0..statsd_uri.index(':8125')-1] + ":4242/api/query"
-            query(request.body[0..request.body.index(":")-1], time_start, time_end)
-          end
-
-        rescue
-          puts "\nFailed to post ".red + request.body.yellow + " to ".red + statsd_uri.blue + " " + num.to_s.red + " time(s)".red
-        end
-
-      else
-        begin
-          time_start = Time.new.to_i.to_s
-
-          response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
-            http.request(request)
-          end
-
-          if options[:q]
-            sleep 15 # ensure data reception and replication
-          end
-
-          time_end = Time.new.to_i.to_s
-
-          if response.code == '200'
-            puts "\nSuccessfully posted ".green + request.body.yellow + " to ".green + statsd_uri.blue + "\nTime start: ".green + time_start.yellow + ", Time end: ".green + time_end.yellow
-
-            if options[:q]
-              opentsdb_uri = statsd_uri[0..statsd_uri.index(':8125')-1] + ":4242/api/query"
-              query(request.body[0..request.body.index(":")-1], time_start, time_end)
-            end
-          end
-        rescue
-          puts "\nFailed to post ".red + request.body.yellow + " to ".red + statsd_uri.blue
-        end
-      end
-      return response
-
-      Helper.new.unset_envs()
-    end
-
-    desc "cpost", "Continuously post metrics to Echo. Use \"echo_cli cpost '<metric>' {frequency} {-v} {-z}\""
-
-    option :z
-    option :v
-
-    long_desc <<-LONGDESC
-      `echo_cli cpost` will continuously post a metric directly to Echo's StatsD server. This process can be killed with "CTRL-c".
+    def post(metric, num = 1)
+      helper = Helper.new
+      helper.set_envs()
+      helper.check_for_IP()
 
-      You can optionally specify a third integer parameter, which will post the metric to Echo at a frequency equal to the integer, in seconds. This value is set to '10 seconds' as the default continuous post frequency.
-
-      Ensure single-quotes surround the metric.
-
-      Ensure the environment variable 'ECHO_CLI_HOST' is set to the correct IP.
-
-      With -v (verbose) option, cpost will continuously output a 'successfully posted' message, with updated times, to the command line.
-
-      With -z (zombie) option, cpost will continuously send posts to Echo in the background, and return its PID for future removal. Use "$ kill -9 <PID>" to kill the zombie process. Specifying this option will override the '-v' option.
-
-      > $ echo_cli cpost 'example.post:1|c' {1} {-v} {-z}
-    LONGDESC
-
-    def cpost(metric, num = 0)
-      Helper.new.check_for_IP()
-
-      statsd_uri = "https://" + ENV["ECHO_CLI_HOST"] + ":8125/metrix"
-
-      Helper.new.set_envs()
-
-      uri = URI.parse(statsd_uri)
-      request = Net::HTTP::Post.new(uri)
-      request["Token"] = "mySecretToken"
-      request.body = metric.gsub(/'/,"")
+      metric = metric.gsub(/'/,"")
+      exit if !helper.check_metric_format(metric)
 
-      req_options = {
-        use_ssl: uri.scheme == "https",
-        verify_mode: OpenSSL::SSL::VERIFY_NONE,
-      }
+      if options[:z]
+        time_start = Time.new.to_i.to_s
 
-      if(num.to_i > 0)
-        s = num.to_i
-      else
-        s = 10
-      end
-
-      if(options[:z])
+        # sort of a mini-smoketest to ensure the posts will work before creating a background process
+        helper.do_post_tcp(ENV["ECHO_CLI_HOST"], "8125", metric)
+        
         pid = Process.fork do
           while true do
-            Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
-              http.request(request)
-            end
-            sleep s
+            helper.do_post_tcp(ENV["ECHO_CLI_HOST"], "8125", metric)
+            sleep 1
           end
         end
-        puts "\nProcess ID: ".green + pid.to_s.yellow + "\nUse ".green + "kill -9 ".yellow + pid.to_s.yellow + " to kill the zombie process.".green
+        puts "\nProcess ID: ".green + pid.to_s.yellow + "\nUse ".green + "$ kill ".yellow + pid.to_s.yellow + " to kill the zombie process.".green
+        puts "Process began posting at ".green + time_start.yellow
       else
-        puts "\nPosting: ".green + metric.yellow + " once every ".green + s.to_s.yellow + " seconds".green + " to ".green + statsd_uri.yellow + "\nPress Ctrl-c to kill the process.\n".green
-        while true do
-          time_start = Time.new.to_i.to_s
-
-          response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
-            http.request(request)
-          end
-
-          sleep s
-
-          time_end = Time.new.to_i.to_s
+        num = num.to_i
+        if num <= 0
+          puts "\nThe number of posts specified is an incorrect expression, or is less than or equal to zero!".red
+          exit
+        end
 
-          if(options[:v] && response.code == '200')
-            puts "\nSuccessfully posted ".green + request.body.yellow + " to ".green + statsd_uri.blue + "\nTime start: ".green + time_start.yellow + ", Time end: ".green + time_end.yellow + "\nPress Ctrl-c to kill the process.\n".green
-          end
+        while num > 0
+          helper.do_post_tcp(ENV["ECHO_CLI_HOST"], "8125", metric)
+          puts "\nPosted ".green + metric.yellow + " to ".green + "http://".yellow + ENV["ECHO_CLI_HOST"].yellow + ":".yellow + "8125".yellow + " at ".green + Time.new.to_i.to_s.yellow
+          num -= 1
         end
       end
 
-      Helper.new.unset_envs()
-
+      helper.unset_envs()
     end
 
-    desc "query", "Query metrics on Echo. Use \"echo_cli query '<metric>' <time_start> <time_end> {-v} {-e} {-s}\""
-
-    option :v
-    option :e
-    option :s
+    desc "query", "Query metrics on Echo. Use \"echo_cli query '<metric>' {time_start} {time_end}\""
 
     long_desc <<-LONGDESC
-      `echo_cli query` will query a metric directly from Echo's OpenTSDB server instance.
-
-      Timestamps are given in epoch time, in seconds.
-
-      If timestamps are unknown, echo_cli's post command provides time_start and time_end values for future querying.
-
-      Ensure single-quotes surround the metric.
-
-      Ensure the environment variable 'ECHO_CLI_HOST' is set to the correct IP.
-
-      Unlike the echo_cli post command, query does not require the data value nor the data type (e.g. remove ':1|c' from 'example.post:1|c' and your query will still work).
-
-      With -v (verbose) option, query will print the status code and response body upon completion of the request.
-
-      With -e (epoch) option, echo_cli will format the response datapoints, with the verbose ('-v') option selected, such that their timestamps will be in epoch format.
-
-      With -s (sql) option, echo_cli will format the response data, with the verbose ('-v') option selected, to be usable within a sql database.
-
-      > $ echo_cli query 'example.post' 1492186212 1492186214 {-v}
-    LONGDESC
+      Query metrics on Echo. Use \"echo_cli query '<metric>' {time_start} {time_end}\"
 
-    def query(metric, time_start, time_end)
-      Helper.new.check_for_IP()
+      `echo_cli query` will query a metric directly from Echo's Graphite server instance.
 
-      opentsdb_uri = "https://" + ENV["ECHO_CLI_HOST"] + ":4242/api/query"
+      The default timestamp query range begins 15 minutes prior to the current time, to now.
 
-      metric = Helper.new.get_metric(metric)
-      metric_name = Helper.new.get_metric_name(metric)
-      tags = Helper.new.check_get_tags(metric)
-      opentsdb_query = Helper.new.get_query(time_start, time_end, metric_name, tags)
+      See: https://graphite-api.readthedocs.io/en/latest/api.html#from-until for possible time_start and time_end formats.
 
-      Helper.new.set_envs()
-
-      uri = URI.parse(opentsdb_uri)
-      https = Net::HTTP.new(uri.host, uri.port)
-      https.use_ssl = false
-      https.verify_mode = OpenSSL::SSL::VERIFY_NONE if https.use_ssl?
-      req = Net::HTTP::Post.new(uri.request_uri, initheader = {'Content-Type' => 'text/plain'}, )
-      req.body = opentsdb_query
-
-      if options[:v]
-        begin
-          res = https.request(req)
-          if res.code == '200'
-
-            json = JSON.parse(res.body)[0]
-
-            if !options[:e]
-              json["dps"] = {}
-              for i in JSON.parse(res.body)[0]["dps"].keys do
-                Helper.new.stfu do
-                  json["dps"][convert(i)] = JSON.parse(res.body)[0]["dps"][i]
-                end
-              end
-            end
-
-            if options[:s]
-              sql = "CREATE TABLE " + metric + "(\n  sep VARCHAR(24) NOT NULL PRIMARY KEY\n  ,FIELD2 VARCHAR(21) NOT NULL\n);"
-              for i in json["dps"].keys do
-                Helper.new.stfu do
-                  sql = sql + "\nINSERT INTO " + metric + "(sep,FIELD2) VALUES ('" + i.to_s + "','" + json["dps"][i].to_s + "');"
-                end
-              end
-
-              puts "\nSuccessfully retrieved ".green + metric_name.yellow + " from ".green + opentsdb_uri.blue + " in timestamp range: ".green + time_start.yellow + " to ".green + time_end.yellow + "\nSQL-ized data points:\n\n".green + sql.green
-            else
-              puts "\nSuccessfully retrieved ".green + metric_name.yellow + " from ".green + opentsdb_uri.blue + " in timestamp range: ".green + time_start.yellow + " to ".green + time_end.yellow + "\nData points:\n\n".green +  JSON.pretty_generate(json).green
-            end
-          else
-            puts "\nFailed to retrieve ".red + metric_name.yellow + " from ".red + opentsdb_uri.blue + " in timestamp range: ".red + time_start.yellow + " to ".red + time_end.yellow + "\nStatus Code: ".red + res.code.yellow + "\nResponse Body: ".red + JSON.pretty_generate(JSON.parse(res.body)).red
-          end
-        rescue
-          puts "\nYour request returned an error. Are you sure your query was correct?"
-        end
-      else
-        begin
-          res = https.request(req)
-          if res.code == '200'
-            puts "\nSuccessfully retrieved ".green + metric_name.yellow + " from ".green + opentsdb_uri.blue + " in timestamp range: ".green + time_start.yellow + " to ".green + time_end.yellow
-          else
-            puts "\nFailed to retrieve ".red + metric_name.yellow + " from ".red + opentsdb_uri.blue + " in timestamp range: ".red + time_start.yellow + " to ".red + time_end.yellow
-          end
-        rescue
-          puts "\nYour request returned an error. Are you sure your query was correct?"
-        end
-      end
-
-      Helper.new.unset_envs()
-
-      return res.code
-    end
-
-    desc "fquery", "Query metrics on Echo from the current time. Use \"echo_cli fquery '<metric>' <range> {-e} {-s}\""
-
-    option :e
-    option :s
-
-    long_desc <<-LONGDESC
-      `echo_cli fquery` (fast query) will query a metric directly from Echo's OpenTSDB server instance for a given time range beginning in the present.
+      The metric-value number (following the ':' in the <metric> string parameter) can be random. The query command does not require this information, it is merely left in place for consistency across commands and ease-of-use.
 
       Ensure single-quotes surround the metric.
 
       Ensure the environment variable 'ECHO_CLI_HOST' is set to the correct IP.
 
-      Unlike the echo_cli post command, fquery does not require the data value nor the data type (e.g. remove ':1|c' from 'example.post:1|c' and your query will still work).
-
-      The <range> parameter is defined in seconds, and is used to query the metric from the current time.
-
-      With -e (epoch) option, echo_cli will format the response datapoints such that their timestamps will be in epoch format.
-
-      With -s (sql) option, echo_cli will format the response data to be usable within a sql database.
-
-      > $ echo_cli fquery 'example' 30
-
-      The previous example would find all data points with metric name 'example' on Echo's OpenTSDB instance at 'localhost' in the last 30 seconds.
+      > $ echo_cli query 'example.query:1|c' {1492186212} {-5min}
     LONGDESC
 
-    def fquery(metric, range)
-      Helper.new.check_for_IP()
-
-      opentsdb_uri = "https://" + ENV["ECHO_CLI_HOST"] + ":4242/api/query"
-
-      time_end = Time.new.to_i
-      time_start = time_end - range.to_i
-      time_start = time_start.to_s
-      time_end = time_end.to_s
-
-      metric = Helper.new.get_metric(metric)
-      metric_name = Helper.new.get_metric_name(metric)
-      tags = Helper.new.check_get_tags(metric)
-      opentsdb_query = Helper.new.get_query(time_start, time_end, metric_name, tags)
-
-      Helper.new.set_envs()
-
-      uri = URI.parse(opentsdb_uri)
-      https = Net::HTTP.new(uri.host, uri.port)
-      https.use_ssl = false
-      https.verify_mode = OpenSSL::SSL::VERIFY_NONE if https.use_ssl?
-      req = Net::HTTP::Post.new(uri.request_uri, initheader = {'Content-Type' => 'text/plain'}, )
-      req.body = opentsdb_query
+    def query(metric, time_start = '-15min', time_end = 'now')
+      helper = Helper.new
+      helper.set_envs()
+      helper.check_for_IP()
+      metric = metric.gsub(/'/,"")
+      exit if !helper.check_metric_format(metric)
 
-      begin
-        res = https.request(req)
-        if res.code == '200'
-
-          json = JSON.parse(res.body)[0]
-
-          if !options[:e]
-            json["dps"] = {}
-            for i in JSON.parse(res.body)[0]["dps"].keys do
-              Helper.new.stfu do
-                json["dps"][convert(i)] = JSON.parse(res.body)[0]["dps"][i]
-              end
-            end
-          end
+      query_url = 'http://' + ENV["ECHO_CLI_HOST"] + ':8080/render?target=' + helper.get_metric_string(metric) + '&from=' + time_start + '&until=' + time_end + '&format=json'
 
-          if options[:s]
-            sql = "CREATE TABLE " + metric + "(\n  sep VARCHAR(24) NOT NULL PRIMARY KEY\n  ,FIELD2 VARCHAR(21) NOT NULL\n);"
-            for i in json["dps"].keys do
-              Helper.new.stfu do
-                sql = sql + "\nINSERT INTO " + metric + "(sep,FIELD2) VALUES ('" + i.to_s + "','" + json["dps"][i].to_s + "');"
-              end
-            end
-
-            puts "\nSuccessfully retrieved ".green + metric_name.yellow + " from ".green + opentsdb_uri.blue + " in timestamp range: ".green + time_start.yellow + " to ".green + time_end.yellow + "\nSQL-ized data points in the last ".green + range.yellow + " seconds:\n\n".green + sql.green
-          else
-            puts "\nSuccessfully retrieved ".green + metric_name.yellow + " from ".green + opentsdb_uri.blue + " in timestamp range: ".green + time_start.yellow + " to ".green + time_end.yellow + "\nData points in the last ".green + range.yellow + " seconds:\n\n".green +  JSON.pretty_generate(json).green
-          end
-        else
-          puts "\nFailed to retrieve ".red + metric_name.yellow + " from ".red + opentsdb_uri.blue + " in timestamp range: ".red + time_start.yellow + " to ".red + time_end.yellow + "\nStatus Code: ".red + res.code.yellow + "\nResponse Body: ".red + JSON.pretty_generate(JSON.parse(res.body)).red
-        end
-      rescue
-        puts "\nYour request returned an error. Are you sure your query was correct?"
+      response = helper.query_graphite(query_url)
+      if(response.code != '200')
+        puts "\nThe query returned a status code of ".red + response.code.yellow + ". If the query has start or end times, ensure they are formatted correctly.".red
+        puts "Otherwise, check your metric query formatting and the 'ECHO_CLI_HOST' environment variable value.".red
+        puts "\nResponse Body:\n".red
+        puts response.body
+      else
+        puts "\nSuccessful Query:\n\n".green + JSON.parse(response.body).to_s.green
       end
-
-      Helper.new.unset_envs()
-
-      return res.code
+      helper.unset_envs()
     end
 
     desc "convert", "Convert timestamp formats. Use \"echo_cli convert <timestamp>\""
 
     long_desc <<-LONGDESC
+      Convert timestamp formats. Use \"echo_cli convert <timestamp>\"
+
       `echo_cli convert` will convert a given timestamp from epoch to a human-readable format, or vice-versa. Useful for determining locations of data on grafana. Ensure that an epoch timestamp has no punctation, and a human-readable timestamp follows the format 'YYYY-MM-DDTHH:MM:SS.SSS-Z' exactly.
 
       Epoch timestamp example: 1492186214
@@ -406,14 +142,15 @@ module Echo_cli
     desc "now", "The current time, in epoch and human-readable formats. Use \"echo_cli now\""
 
     long_desc <<-LONGDESC
-    `echo_cli now` will present the current timestamp (based on your computer's local time) to more easily utilize the rest of the Echo CLI commands.
+      The current time, in epoch and human-readable formats. Use \"echo_cli now\"
 
-    Epoch timestamp example: 1492186214
+      `echo_cli now` will present the current timestamp (based on your computer's local time) to more easily utilize the rest of the Echo CLI commands.
 
-    Human-readable date/time timestamp example: 2011-10-18T21:01:52-07:00
+      Epoch timestamp example: 1492186214
 
-    > $ echo_cli now
+      Human-readable date/time timestamp example: 2011-10-18T21:01:52-07:00
 
+      > $ echo_cli now
     LONGDESC
 
     def now
@@ -423,6 +160,7 @@ module Echo_cli
   end
 
   class Helper
+    # useful silencing function, plz leave here
     def stfu
       begin
         orig_stderr = $stderr.clone
@@ -441,61 +179,6 @@ module Echo_cli
       retval
     end
 
-    def check_get_tags(metric)
-      tags = ""
-
-      if metric.include? "."
-        tags = metric[metric.index(".")+1..-1] + "."
-        metric = metric[0..metric.index(".")-1]
-
-        toReturn = ""
-        count = 1
-        while tags.include?(".") do
-          toReturn = toReturn + "\"tag" + count.to_s + "\": \"" + tags[0..tags.index(".")-1] + "\""
-          count = count + 1
-          tags = tags[tags.index(".")+1..-1]
-          if tags.include?(".")
-            toReturn = toReturn + ",\n"
-          end
-        end
-
-        tags = toReturn
-      end
-      return tags
-    end
-
-    def get_metric(metric)
-      metric = metric.gsub(/'/,"")
-      if metric.include? ":"
-        metric = metric[0..metric.index(":")-1]
-      end
-      return metric
-    end
-
-    def get_metric_name(metric)
-      if metric.include?(".")
-        metric = metric[0..metric.index(".")-1]
-      end
-      return metric
-    end
-
-    def get_query(time_start, time_end, metric, tags)
-      opentsdb_query =
-      "{
-        \"start\": " + time_start + ",
-        \"end\": " + time_end + ",
-        \"queries\": [
-          {
-          \"aggregator\": \"sum\",
-          \"metric\": \"" + metric + "\",
-          \"tags\": {" + tags +
-            "}
-          }
-        ]
-      }"
-      return opentsdb_query
-    end
-
     def set_envs
       ENV["http_proxy"] = ENV["HTTP_PROXY"]
       ENV["https_proxy"] = ENV["HTTPS_PROXY"]
@@ -512,5 +195,50 @@ module Echo_cli
         exit
       end
     end
+
+    def get_metric_string(metric)
+      type = metric[metric.index('|') + 1 .. metric.length]
+      case type
+      when 'c'
+        return "stats.counters." + metric[0..metric.index(':')-1] + ".count"
+      when 'ms'
+        return "stats.timers." + metric[0..metric.index(':')-1]
+      when 's'
+        return "stats.sets." + metric[0..metric.index(':')-1]
+      when 'g'
+        return "stats.gauges." + metric[0..metric.index(':')-1]
+      end
+    end
+
+    def check_metric_format(metric)
+      if /.*(:\d*\.?\d*)\|(ms|c|g|s)/.match(metric).to_s != metric
+        puts "\nThe posted metric was not of the correct form.\nMetrics must be of the form <metric>.<tag1>.<tag2>...<tagN>:<value>|<type>".red
+        puts "Where <value> is a number, and <type> is any of the following: 'ms', 'c', 's', 'g'.".red
+        return false
+      end
+      return true
+    end
+
+    def do_post_tcp(statsd_uri, port, request_body)
+      begin
+        timeout(10) do
+          socket = TCPSocket.new(statsd_uri, port)
+          socket.puts(request_body)
+        end
+      rescue Timeout::Error
+        puts "\nOperation timed out! Ensure the 'ECHO_CLI_HOST' environment variable is correct.".red
+        exit
+      end
+    end
+
+    def query_graphite(graphite_uri)
+      uri = URI.parse(graphite_uri)
+      https = Net::HTTP.new(uri.host, uri.port)
+      https.use_ssl = false
+      https.verify_mode = OpenSSL::SSL::VERIFY_NONE if https.use_ssl?
+      req = Net::HTTP::Get.new(uri.request_uri, initheader = {'Content-Type' => 'text/plain'}, )
+      res = https.request(req)
+      return res
+    end
   end
 end

data/lib/echo_cli/version.rb

@@ -1,3 +1,3 @@
 module Echo_cli
-  VERSION = "0.6.25"
+  VERSION = "0.6.28"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: echo_cli
 version: !ruby/object:Gem::Version
-  version: 0.6.25
+  version: 0.6.28
 platform: ruby
 authors:
 - Brandon Raphael
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-25 00:00:00.000000000 Z
+date: 2017-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor