wavefront-cli 0.0.2

data/lib/wavefront-cli/display/cloudintegration.rb

@@ -0,0 +1,18 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for cloud integrations.
+  #
+  class CloudIntegration < Base
+    def do_list_brief
+      terse_output(:id, :service)
+    end
+
+    def do_describe
+      readable_time(:lastReceivedDataPointMs, :lastProcessingTimestamp)
+      drop_fields(:forceSave)
+      long_output
+    end
+  end
+end

data/lib/wavefront-cli/display/dashboard.rb

@@ -0,0 +1,21 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for dashboards.
+  #
+  class Dashboard < Base
+    def do_list
+      long_output [:id, :minutes, :target, :status, :tags, :hostsUsed,
+                   :condition, :displayExpression, :severity,
+                   :additionalInformation]
+    end
+
+    def do_describe
+      drop_fields(:parameterDetails)
+      readable_time(:updatedEpochMillis)
+      data[:sections] = data[:sections].map { |s| s[:name] }
+      long_output
+    end
+  end
+end

data/lib/wavefront-cli/display/event.rb

@@ -0,0 +1,19 @@
+require 'date'
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for events.
+  #
+  class Event < Base
+    def do_describe
+      readable_time(:startTime, :endTime, :updatedAt, :createdAt,
+                    :createdEpochMillis, :updatedEpochMillis)
+      long_output
+    end
+
+    def do_list_brief
+      terse_output(:id, :runningState)
+    end
+  end
+end

data/lib/wavefront-cli/display/externallink.rb

@@ -0,0 +1,13 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for external links.
+  #
+  class ExternalLink < Base
+    def do_describe
+      readable_time(:createdEpochMillis, :updatedEpochMillis)
+      long_output
+    end
+  end
+end

data/lib/wavefront-cli/display/maintenancewindow.rb

@@ -0,0 +1,19 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for maintenance windows.
+  #
+  class MaintenanceWindow < Base
+    def do_describe
+      readable_time(:startTimeInSeconds, :endTimeInSeconds,
+                    :createdEpochMillis, :updatedEpochMillis)
+      drop_fields(:hostTagGroupHostNamesGroupAnded, :relevantHostTagsAnded)
+      long_output
+    end
+
+    def do_list_brief
+      terse_output(:id, :title)
+    end
+  end
+end

data/lib/wavefront-cli/display/message.rb

@@ -0,0 +1,8 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for messages.
+  #
+  class Message < Base; end
+end

data/lib/wavefront-cli/display/metric.rb

@@ -0,0 +1,22 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for metrics.
+  #
+  class Metric < Base
+    def do_describe
+      if data.hosts.empty?
+        puts "No matches."
+        exit
+      end
+
+      modified_data = data['hosts'].map do |h, aggr|
+        { host:        h[:host],
+          last_update: human_time(h[:last_update]) }
+      end.sort_by{ |h| h[:last_update] }.reverse
+
+      terse_output(:host, :last_update, modified_data)
+    end
+  end
+end

data/lib/wavefront-cli/display/proxy.rb

@@ -0,0 +1,13 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for proxies.
+  #
+  class Proxy < Base
+    def do_describe
+      readable_time(:lastCheckInTime)
+      long_output
+    end
+  end
+end

data/lib/wavefront-cli/display/query.rb

@@ -0,0 +1,69 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for queries.
+  #
+  class Query < Base
+    def do_default
+
+      ts = if data.key?(:timeseries)
+             data[:timeseries].each do |s|
+               s[:data] = humanize_series(s[:data])
+             end
+           else
+             []
+           end
+
+      events = if data.key?(:events)
+                 data[:events].map { |s| humanize_event(s) }
+               else
+                 []
+               end
+
+      new = {
+        name: data.name,
+        query: data.query,
+        timeseries: ts,
+        events: events
+      }
+
+      @data = new
+      long_output
+    end
+
+    def do_raw
+      data.each { |ts| puts humanize_series(ts[:points]).join("\n") }
+    end
+
+    def do_raw_404
+      puts 'API 404: metric does not exist.'
+    end
+
+    def humanize_event(data)
+      data[:start] = human_time(data[:start])
+      data[:end] = human_time(data[:end]) if data[:end]
+      data.delete(:isEphemeral)
+      data
+    end
+
+    def humanize_series(data)
+      last_date = nil
+
+      data.map! do |row|
+        if row.is_a?(Hash)
+          ht = human_time(row[:timestamp])
+          val = row[:value]
+        else
+          ht = human_time(row[0])
+          val = row[1]
+        end
+
+        date, time = ht.split
+        ds = date == last_date ? '' : date
+        last_date = date
+        format('%12s %s    %s', ds, time, val)
+      end
+    end
+  end
+end

data/lib/wavefront-cli/display/savedsearch.rb

@@ -0,0 +1,17 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for saved searches.
+  #
+  class SavedSearch < Base
+    def do_describe
+      readable_time(:createdEpochMillis, :updatedEpochMillis)
+      long_output
+    end
+
+    def do_list_brief
+      terse_output(:id, :entityType)
+    end
+  end
+end

data/lib/wavefront-cli/display/source.rb

@@ -0,0 +1,26 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for webhooks.
+  #
+  class Source < Base
+    def do_list
+      drop_cluster_sources
+      long_output
+    end
+
+    def do_list_brief
+      drop_cluster_sources
+      terse_output(:id, :description)
+    end
+
+    # Filter out the Wavefront cluster sources
+    #
+    def drop_cluster_sources
+      data.sort_by! { |k, _v| k }
+      return if options[:all]
+      data.delete_if { |k| k.id =~ /prod-[\da-f]{2}-/ }
+    end
+  end
+end

data/lib/wavefront-cli/display/user.rb

@@ -0,0 +1,16 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for user management.
+  #
+  class User < Base
+    def do_list_brief
+      data.each { |user| puts user[:identifier] }
+    end
+
+    def do_delete
+      puts "Deleted user '#{options[:'<id>']}."
+    end
+  end
+end

data/lib/wavefront-cli/display/webhook.rb

@@ -0,0 +1,24 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for webhooks.
+  #
+  class Webhook < Base
+    def do_list
+      long_output([:id, :description, :createdEpochMillis,
+                   :updatedEpochMillis, :updaterId, :creatorId,
+                   :title])
+    end
+
+    def do_list_brief
+      terse_output(:id, :title)
+    end
+
+    def do_describe
+      readable_time(:createdEpochMillis, :updatedEpochMillis)
+      drop_fields(:template)
+      long_output
+    end
+  end
+end

data/lib/wavefront-cli/display/write.rb

@@ -0,0 +1,19 @@
+require_relative './base'
+
+module WavefrontDisplay
+  # Format human-readable output when writing points.
+  #
+  class Write < Base
+    def do_point
+      [:sent, :rejected, :unsent].each do |k|
+        puts format('  %12s %d', k.to_s, data[k])
+      end
+
+      exit(data.rejected.zero? && data.unsent.zero? ? 0 : 1)
+    end
+
+    def do_file
+      do_point
+    end
+  end
+end

data/lib/wavefront-cli/event.rb

@@ -0,0 +1,162 @@
+require 'fileutils'
+require 'wavefront-sdk/mixins'
+require_relative './base'
+
+EVENT_STATE_DIR = Pathname.new('/var/tmp/wavefront')
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'event' API.
+  #
+  class Event < WavefrontCli::Base
+    attr_reader :state_dir
+    include Wavefront::Mixins
+
+    def post_initialize(_options)
+      begin
+        @state_dir = EVENT_STATE_DIR + Etc.getlogin
+      rescue
+        @state_dir = EVENT_STATE_DIR + 'notty'
+      end
+
+      create_state_dir
+    end
+
+    def do_list
+      options[:start] = Time.now - 600 unless options[:start]
+      options[:end] = Time.now unless options[:end]
+      wf.list(options[:start], options[:end], options[:limit] || 100,
+              options[:offset] || nil)
+    end
+
+    def do_update
+      k, v = options[:'<key=value>'].split('=')
+      wf.update(options[:'<id>'], k => v)
+    end
+
+    def do_create
+      options[:start] = Time.now unless options[:start]
+
+      t_start = parse_time(options[:start], true)
+      id = [t_start, options[:'<event>']].join(':')
+
+      body = { name:        options[:'<event>'],
+               startTime:   t_start,
+               id:          id,
+               annotations: {} }
+
+      body[:annotations][:details] = options[:desc] if options[:desc]
+      body[:annotations][:severity] = options[:severity] if options[:severity]
+      body[:annotations][:type] = options[:type] if options[:type]
+      body[:hosts] = options[:host] if options[:host]
+
+      if options[:instant]
+        body[:endTime] = t_start + 1
+      elsif options[:end]
+        body[:endTime] = parse_time(options[:end], true)
+      end
+
+      resp = wf.create(body)
+
+      unless options[:nostate] || options[:end] || options[:instant]
+        create_state_file(id, options[:host])
+      end
+
+      resp
+    end
+
+    # The user doesn't have to give us an event ID.  If no event
+    # name is given, we'll pop the last event off the stack. If an
+    # event name is given and it doesn't look like a full WF event
+    # name, we'll look for something on the stack.  If it does look
+    # like a real event, we'll make and API call straight away.
+    #
+    def do_close
+      ev_file = nil
+
+      ev = if options[:'<id>'] == false
+             pop_event
+           elsif options[:'<id>'] =~ /^\d{13}:.+/
+             ev_file = state_dir + options[:'<id>']
+             options[:'<id>']
+           else
+             pop_event(options[:'<id>'])
+           end
+
+      abort "No locally stored event matches '#{options[:'<id>']}'." unless ev
+
+      res = wf.close(ev)
+      ev_file.unlink if ev_file && ev_file.exist? && res.status.code == 200
+      res
+    end
+
+    def do_show
+      begin
+        events = state_dir.children
+      rescue Errno::ENOENT
+        raise 'There is no event state directory on this host.'
+      end
+
+      if events.size.zero?
+        puts 'No open events.'
+      else
+        events.sort.reverse.each { |e| puts e.basename }
+      end
+
+      exit
+    end
+
+    private
+
+    # Write a state file. We put the hosts bound to the event into the
+    # file. These aren't currently used by anything in the CLI, but they
+    # might be useful to someone, somewhere, someday.
+    #
+    def create_state_file(id, hosts = [])
+      puts "statfile fir #{id}"
+      fname = state_dir + id
+
+      begin
+        File.open(fname, 'w') { hosts.to_s }
+      rescue
+        raise 'Event was created but state file was not.'
+      end
+
+      puts "Event state recorded at #{fname}."
+    end
+
+    def create_state_dir
+      FileUtils.mkdir_p(state_dir)
+      return true if state_dir.exist? && state_dir.directory? &&
+                     state_dir.writable?
+      raise 'Cannot create state directory.'
+    end
+
+    def validate_input
+      validate_id if options[:'<id>'] && !options[:close]
+      validate_tags if options[:'<tag>']
+      send(:extra_validation) if respond_to?(:extra_validation)
+    end
+
+    # Get the last event this script created. If you supply a name, you
+    # get the last event with that name. If not, you get the last event.
+    # Chances are you'll only ever have one in-play at once.
+    #
+    # @param name [String] name of event
+    # Returns an array of [timestamp, event_name]
+    #
+    def pop_event(name = false)
+      return false unless state_dir.exist?
+
+      list = state_dir.children
+
+      list.select! { |f| f.basename.to_s.split(':').last == name } if name
+
+      return false if list.empty?
+
+      ev_file = list.sort.last
+      File.unlink(ev_file)
+      ev_file.basename.to_s
+    end
+  end
+end