awful 0.0.152 → 0.0.153

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e9cf294dcdf1b576e46d1737c8a8d209b317208
-  data.tar.gz: 76d39a1f0288bbc5727ba0d481d707d633ee44c4
+  metadata.gz: 96d3e0155175c85b636ee238c2b5eb481643187e
+  data.tar.gz: '0294c90dfe5e0b1ec0273f2f26052870eb241e61'
 SHA512:
-  metadata.gz: c88e205ba51cb5365e1224e8ab73b6a0893702c60720821ff346a77dc440acc0193eaf2e688c25894196d2f3b7b6bd26ea7a0b37465168911efd0c2e2ff3a2a6
-  data.tar.gz: 1c0e24efd8f3787b345233bb9f7d725e51a893626812d719029e514b9433e5bf4afb2f70e11106fdaa631d3bcbb98c905b14fe1f9d69ae18ddf125ee72e102eb
+  metadata.gz: 1fda7ef50c77ce9a36403d60341c0c458532a98cc1bd0714425737d341c9b23910b8d5c6e546695fc34ba007d56e2303e90f71943d9ce6cdfd36666be0d06dfd
+  data.tar.gz: 752f8cc8f91cadad15d2a8615978c13e0e00c01283cce9098facb97d14a3e82723a741280e13135ff913b51589fc565b8a6cc3e77b5bd2c29c8a6e9c20297a66

data/lib/awful.rb

@@ -164,6 +164,19 @@ module Awful
         end
       end
 
+      ## universal paginator for aws-sdk calls
+      def paginate(thing)
+        token = nil
+        things = []
+        loop do
+          resp = yield(token)
+          things += resp.send(thing)
+          ## some apis use marker, some use token
+          token = resp.respond_to?(:next_marker) ? resp.next_marker : resp.next_token
+          break if token.nil?
+        end
+        things
+      end
     end
   end
 end

data/lib/awful/cloudwatch_logs.rb

@@ -1,3 +1,5 @@
+require 'time'
+
 module Awful
   module Short
     def cwlogs(*args)
@@ -10,28 +12,29 @@ module Awful
       def logs
         @logs ||= Aws::CloudWatchLogs::Client.new
       end
+
+      ## human-readable timestamp
+      def human_time(timestamp)
+        if timestamp.nil?
+          '-'
+        else
+          Time.at(timestamp.to_i/1000)
+        end
+      end
     end
 
     desc 'ls [PREFIX]', 'list log groups'
     method_option :long, aliases: '-l', default: false, desc: 'Long listing'
     def ls(prefix = nil)
-      next_token = nil
-      log_groups = []
-      loop do
-        response = logs.describe_log_groups(log_group_name_prefix: prefix, next_token: next_token)
-        log_groups = log_groups + response.log_groups
-        next_token = response.next_token
-        break if next_token.nil?
-      end
-
-      ## return and output groups
-      log_groups.output do |groups|
+      paginate(:log_groups) do |token|
+        logs.describe_log_groups(log_group_name_prefix: prefix, next_token: token)
+      end.output do |groups|
         if options[:long]
           print_table groups.map { |group|
             [
               group.log_group_name,
               group.retention_in_days,
-              Time.at(group.creation_time.to_i/1000),
+              human_time(group.creation_time),
               group.stored_bytes,
             ]
           }
@@ -52,30 +55,23 @@ module Awful
     end
 
     desc 'streams GROUP [PREFIX]', 'list log streams for GROUP'
-    method_option :long,  aliases: '-l', default: false, desc: 'Long listing'
-    method_option :limit, aliases: '-n', default: 50,    desc: 'Count to limit returned results'
-    method_option :alpha, aliases: '-a', default: false, desc: 'Order by name'
+    method_option :long,  aliases: '-l', default: false, desc: 'long listing'
+    method_option :limit, aliases: '-n', default: 50,    desc: 'limit number of results per page call'
+    method_option :alpha, aliases: '-a', default: false, desc: 'order by name'
     def streams(group, prefix = nil)
-      next_token = nil
-      log_streams = []
-      loop do
-        response = logs.describe_log_streams(
+      paginate(:log_streams) do |token|
+        logs.describe_log_streams(
           log_group_name: group,
           log_stream_name_prefix: prefix,
           order_by: options[:alpha] ? 'LogStreamName' : 'LastEventTime',
           descending: (not options[:alpha]), # want desc order if by time for most recent first
           limit: options[:limit],
-          next_token: next_token
+          next_token: token,
         )
-        log_streams = log_streams + response.log_streams
-        next_token = response.next_token
-        break if next_token.nil?
-        break if log_streams.count >= options[:limit].to_i
-      end
-      log_streams.output do |streams|
+      end.output do |streams|
         if options[:long]
           print_table streams.map { |s|
-            [ s.log_stream_name, Time.at(s.creation_time.to_i/1000), Time.at(s.last_event_timestamp.to_i/1000) ]
+            [ s.log_stream_name, human_time(s.creation_time), human_time(s.last_event_timestamp) ]
           }
         else
           puts streams.map(&:log_stream_name)
@@ -145,12 +141,69 @@ module Awful
 
       events.output do |ev|
         if options[:long]
-          print_table ev.map { |e| [Time.at(e.timestamp.to_i/1000), e.message] }
+          print_table ev.map { |e| [human_time(e.timestamp), e.message] }
         else
           puts ev.map(&:message)
         end
       end
     end
 
+    desc 'filter GROUP [STREAMS]', 'filter'
+    method_option :pattern, aliases: '-p', type: :string, default: nil, desc: 'pattern to filter logs'
+    method_option :start,   aliases: '-s', type: :string, default: nil, desc: 'start time'
+    method_option :end,     aliases: '-e', type: :string, default: nil, desc: 'end time'
+    def filter(group, *streams)
+      start_time = options[:start] ? Time.parse(options[:start]).to_i*1000 : nil
+      end_time   = options[:end]   ? Time.parse(options[:end]).to_i*1000   : nil
+      token = nil
+      loop do
+        resp = logs.filter_log_events(
+          log_group_name: group,
+          log_stream_names: streams.empty? ? nil : streams,
+          next_token: token,
+          start_time: start_time,
+          end_time: end_time,
+          filter_pattern: options[:pattern],
+        )
+        resp.events.each do |e|
+          time   = set_color(human_time(e.timestamp).utc, :green)
+          stream = set_color(e.log_stream_name, :blue)
+          puts("#{time}  #{stream}  #{e.message}")
+        end
+        token = resp.next_token
+        break unless token
+      end
+    end
+
+    desc 'tail GROUP [STREAMS]', 'tail log group streams'
+    method_option :numlines, aliases: '-n', type: :numeric, default: 10,    desc: 'number of lines to show'
+    method_option :follow,   aliases: '-f', type: :boolean, default: false, desc: 'follow log output'
+    method_option :sleep,    aliases: '-s', type: :numeric, default: 3,     desc: 'seconds to sleep between poll for new data'
+    method_option :timestamp,               type: :boolean, default: true,  desc: 'show timestamp for each line'
+    def tail(group, stream)
+      trap('SIGINT', 'EXIT')    # expect to exit with ctrl-c
+
+      ## how to print each line
+      out = if options[:timestamp]
+        ->(e) { puts("#{set_color(human_time(e.timestamp).utc, :green)}  #{e.message}") }
+      else
+        ->(e) { puts e.message }
+      end
+
+      token = nil
+      loop do
+        resp = logs.get_log_events(
+          log_group_name: group,
+          log_stream_name: stream,
+          limit: options[:numlines],
+          next_token: token,
+        )
+        resp.events.each do |e|
+          out.call(e)
+        end
+        token = resp.next_forward_token
+        options[:follow] ? sleep(options[:sleep]) : break
+      end
+    end
   end
 end

data/lib/awful/kms.rb

@@ -22,17 +22,17 @@ module Awful
         set_color(string, COLORS.fetch(string.to_sym, :yellow))
       end
 
-      def paginate(thing)
-        next_marker = nil
-        things = []
-        loop do
-          response = yield(next_marker)
-          things += response.send(thing)
-          next_marker = response.next_marker
-          break unless next_marker
-        end
-        things
-      end
+      # def paginate(thing)
+      #   next_marker = nil
+      #   things = []
+      #   loop do
+      #     response = yield(next_marker)
+      #     things += response.send(thing)
+      #     next_marker = response.next_marker
+      #     break unless next_marker
+      #   end
+      #   things
+      # end
 
       def aliases
         paginate(:aliases) do |marker|

data/lib/awful/version.rb

@@ -1,3 +1,3 @@
 module Awful
-  VERSION = '0.0.152'
+  VERSION = '0.0.153'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: awful
 version: !ruby/object:Gem::Version
-  version: 0.0.152
+  version: 0.0.153
 platform: ruby
 authors:
 - Ric Lister
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-28 00:00:00.000000000 Z
+date: 2016-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -224,7 +224,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Simple AWS command-line tool.