meteorlog 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29de27158912619561019ddd020283b84d17ba3c
+  data.tar.gz: 994519363b62e6df8367bfb5f4c691dc7582759d
+SHA512:
+  metadata.gz: 942ac817e7daab22123cfc96aef611ee079d2752fe7e6a5efe5193b16e0d286274c5e610047c419cd9238fdcd14e3ac1767066e2fa5a336a877be1703d629b92
+  data.tar.gz: f719f786635167f42ef4fc6673fc5b3c9835549ec56e2e07f24d2312af47718dcf3847701de3571c050b5a08e6e3a3e0c2bb2a4c095b09bbf730979cb5f2e27f

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+test.rb
+Logsfile
+*.swp

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in meteorlog.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Genki Sugawara
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,84 @@
+# Meteorlog
+
+Meteorlog is a tool to manage CloudWatch Logs.
+
+It defines the state of CloudWatch Logs using DSL, and updates CloudWatch Logs according to DSL.
+
+[![Gem Version](https://badge.fury.io/rb/meteorlog.svg)](http://badge.fury.io/rb/meteorlog)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'meteorlog'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install meteorlog
+
+## Usage
+
+```sh
+export AWS_ACCESS_KEY_ID='...'
+export AWS_SECRET_ACCESS_KEY='...'
+export AWS_REGION='us-east-1'
+meteorlog -e -o Logsfile  # export CloudWatch Logs
+vi Logsfile
+meteorlog -a --dry-run
+meteorlog -a               # apply `Logsfile` to CloudWatch Logs
+```
+
+## Help
+
+```
+Usage: meteorlog [options]
+    -p, --profile PROFILE_NAME
+    -k, --access-key ACCESS_KEY
+    -s, --secret-key SECRET_KEY
+    -r, --region REGION
+    -a, --apply
+    -f, --file FILE
+        --dry-run
+    -e, --export
+    -o, --output FILE
+        --no-color
+        --debug
+```
+
+## Logsfile example
+
+```ruby
+require 'other/logsfile'
+
+log_group "/var/log/messages" do
+  log_stream "my-stream"
+
+  metric_filter "MyAppAccessCount" do
+    metric :name=>"EventCount", :namespace=>"YourNamespace", :value=>"1"
+  end
+
+  metric_filter "MyAppAccessCount2" do
+    # see http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/FilterAndPatternSyntax.html
+    filter_pattern '[ip, user, username, timestamp, request, status_code, bytes > 1000]'
+    metric :name=>"EventCount2", :namespace=>"YourNamespace2", :value=>"2"
+  end
+end
+
+log_group "/var/log/maillog" do
+  log_stream "my-stream2"
+
+  metric_filter "MyAppAccessCount" do
+    filter_pattern '[..., status_code, bytes]'
+    metric :name=>"EventCount3", :namespace=>"YourNamespace", :value=>"1"
+  end
+
+  metric_filter "MyAppAccessCount2" do
+    filter_pattern '[ip, user, username, timestamp, request = *html*, status_code = 4*, bytes]'
+    metric :name=>"EventCount4", :namespace=>"YourNamespace2", :value=>"2"
+  end
+end
+```

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+task :default => :spec

data/bin/meteorlog

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("#{File.dirname __FILE__}/../lib")
+require 'rubygems'
+require 'meteorlog'
+require 'optparse'
+
+Version = Meteorlog::VERSION
+DEFAULT_FILENAME = 'Logsfile'
+
+mode = nil
+file = DEFAULT_FILENAME
+output_file = '-'
+
+options = {
+  :dry_run => false,
+  :color   => true,
+  :debug   => false,
+}
+
+ARGV.options do |opt|
+  begin
+    access_key = nil
+    secret_key = nil
+    region = nil
+    profile_name = nil
+
+    opt.on('-p', '--profile PROFILE_NAME')  {|v| profile_name      = v       }
+    opt.on('-k', '--access-key ACCESS_KEY') {|v| access_key        = v       }
+    opt.on('-s', '--secret-key SECRET_KEY') {|v| secret_key        = v       }
+    opt.on('-r', '--region REGION')         {|v| region            = v       }
+    opt.on('-a', '--apply')                 {    mode              = :apply  }
+    opt.on('-f', '--file FILE')             {|v| file              = v       }
+    opt.on('',   '--dry-run')               {    options[:dry_run] = true    }
+    opt.on('-e', '--export')                {    mode              = :export }
+    opt.on('-o', '--output FILE')           {|v| output_file       = v       }
+    opt.on(''  , '--no-color')              {    options[:color]   = false   }
+    opt.on(''  , '--debug')                 {    options[:debug]   = true    }
+    opt.parse!
+
+    aws_opts = {}
+
+    if access_key and secret_key
+      aws_opts.update(
+        :access_key_id     => access_key,
+        :secret_access_key => secret_key
+      )
+    elsif profile_name
+      credentials = Aws::SharedCredentials.new(:profile_name => profile_name)
+      aws_opts[:credentials] = credentials
+    elsif (access_key and !secret_key) or (!access_key and secret_key) or mode.nil?
+      puts opt.help
+      exit 1
+    end
+
+    aws_opts[:region] = region if region
+    Aws.config.update(aws_opts)
+  rescue => e
+    $stderr.puts("[ERROR] #{e.message}")
+    exit 1
+  end
+end
+
+String.colorize = options[:color]
+
+if options[:debug]
+  AWS.config({
+    :http_wire_trace => true,
+    :logger => Meteorlog::Logger.instance,
+  })
+end
+
+begin
+  logger = Meteorlog::Logger.instance
+  logger.set_debug(options[:debug])
+  client = Meteorlog::Client.new(options)
+
+  case mode
+  when :export
+    if output_file == '-'
+      logger.info('# Export Logs')
+      puts client.export(options)
+    else
+      logger.info("Export Logs to `#{output_file}`")
+      open(output_file, 'wb') {|f| f.puts client.export(options) }
+    end
+  when :apply
+    unless File.exist?(file)
+      raise "No Logsfile found (looking for: #{file})"
+    end
+
+    msg = "Apply `#{file}` to CloudWatch Logs"
+    msg << ' (dry-run)' if options[:dry_run]
+    logger.info(msg)
+
+    updated = client.apply(file)
+
+    logger.info('No change'.intense_blue) unless updated
+  else
+    raise 'must not happen'
+  end
+rescue => e
+  if options[:debug]
+    raise e
+  else
+    $stderr.puts("[ERROR] #{e.message}".red)
+    exit 1
+  end
+end

data/lib/meteorlog/client.rb

@@ -0,0 +1,104 @@
+class Meteorlog::Client
+  include Meteorlog::Logger::Helper
+  include Meteorlog::Utils
+
+  def initialize(options = {})
+    @options = options
+    @cloud_watch_logs = Aws::CloudWatchLogs::Client.new
+  end
+
+  def export(opts = {})
+    exported = Meteorlog::Exporter.export(@cloud_watch_logs, @options.merge(opts))
+    Meteorlog::DSL.convert(exported, @options.merge(opts))
+  end
+
+  def apply(file)
+    walk(file)
+  end
+
+  private
+
+  def walk(file)
+    dsl = load_file(file)
+    dsl_log_groups = collect_to_hash(dsl.log_groups, :log_group_name)
+    aws = Meteorlog::Wrapper.wrap(@cloud_watch_logs, @options)
+    aws_log_groups = collect_to_hash(aws.log_groups, :log_group_name)
+
+    dsl_log_groups.each do |log_group_name, dsl_log_group|
+      aws_log_group = aws_log_groups[log_group_name]
+
+      unless aws_log_group
+        aws_log_group = aws.log_groups.create(log_group_name)
+        aws_log_groups[log_group_name] = aws_log_group
+      end
+    end
+
+    dsl_log_groups.each do |log_group_name, dsl_log_group|
+      aws_log_group = aws_log_groups.delete(log_group_name)
+      walk_log_group(dsl_log_group, aws_log_group)
+    end
+
+    aws_log_groups.each do |log_group_name, aws_log_group|
+      aws_log_group.delete
+    end
+
+    aws.modified?
+  end
+
+  def walk_log_group(dsl_log_group, aws_log_group)
+    walk_log_streams(dsl_log_group.log_streams, aws_log_group.log_streams)
+    walk_metric_filters(dsl_log_group.metric_filters, aws_log_group.metric_filters)
+  end
+
+  def walk_log_streams(dsl_log_streams, aws_log_streams)
+    collection_api = aws_log_streams
+    dsl_log_streams = collect_to_hash(dsl_log_streams, :log_stream_name)
+    aws_log_streams = collect_to_hash(aws_log_streams, :log_stream_name)
+
+    dsl_log_streams.each do |log_stream_name, dsl_log_stream|
+      aws_log_stream = aws_log_streams.delete(log_stream_name)
+
+      unless aws_log_stream
+        collection_api.create(log_stream_name)
+      end
+    end
+
+    aws_log_streams.each do |log_stream_name, aws_log_stream|
+      aws_log_stream.delete
+    end
+  end
+
+  def walk_metric_filters(dsl_metric_filters, aws_metric_filters)
+    collection_api = aws_metric_filters
+    dsl_metric_filters = collect_to_hash(dsl_metric_filters, :filter_name)
+    aws_metric_filters = collect_to_hash(aws_metric_filters, :filter_name)
+
+    dsl_metric_filters.each do |filter_name, dsl_metric_filter|
+      aws_metric_filter = aws_metric_filters.delete(filter_name)
+
+      if aws_metric_filter
+        unless aws_metric_filter.eql?(dsl_metric_filter)
+          aws_metric_filter.update(dsl_metric_filter)
+        end
+      else
+        collection_api.create(filter_name, dsl_metric_filter)
+      end
+    end
+
+    aws_metric_filters.each do |filter_name, aws_metric_filter|
+      aws_metric_filter.delete
+    end
+  end
+
+  def load_file(file)
+    if file.kind_of?(String)
+      open(file) do |f|
+        Meteorlog::DSL.parse(f.read, file)
+      end
+    elsif file.respond_to?(:read)
+      Meteorlog::DSL.parse(file.read, file.path)
+    else
+      raise TypeError, "can't convert #{file} into File"
+    end
+  end
+end

data/lib/meteorlog/dsl/context/log_group.rb

@@ -0,0 +1,33 @@
+class Meteorlog::DSL::Context::LogGroup
+  include Meteorlog::DSL::Validator
+
+  attr_reader :result
+
+  def initialize(name, &block)
+    @error_identifier = "LogGroup `#{name}`"
+    @result = OpenStruct.new(
+      :log_group_name => name,
+      :log_streams => [],
+      :metric_filters => [],
+    )
+    instance_eval(&block)
+  end
+
+  def log_stream(name)
+    _required(:log_stream_name, name)
+    _validate("LogStream `#{name}` is already defined") do
+      @result.log_streams.all? {|i| i.log_stream_name != name }
+    end
+
+    @result.log_streams << OpenStruct.new(:log_stream_name => name)
+  end
+
+  def metric_filter(name, &block)
+    _required(:filter_name, name)
+    _validate("MetricFilter `#{name}` is already defined") do
+      @result.metric_filters.all? {|i| i.filter_name != name }
+    end
+
+    @result.metric_filters << Meteorlog::DSL::Context::MetricFilter.new(name, @result.log_group_name, &block).result
+  end
+end

data/lib/meteorlog/dsl/context/metric_filter.rb

@@ -0,0 +1,36 @@
+class Meteorlog::DSL::Context::MetricFilter
+  include Meteorlog::DSL::Validator
+
+  attr_reader :result
+
+  def initialize(name, log_group_name, &block)
+    @error_identifier = "LogGroup `#{log_group_name}` > MetricFilter `#{name}`"
+    @result = OpenStruct.new(
+      :filter_name => name,
+      :metric_transformations => [],
+    )
+    instance_eval(&block)
+  end
+
+  def filter_pattern(pattern)
+    _call_once(:filter_pattern)
+    _required(:filter_pattern, pattern)
+    @result.filter_pattern = pattern.to_s
+  end
+
+  def metric(attrs)
+    metric_attrs = {}
+    _expected_type(attrs, Hash)
+    {
+      :name => :metric_name,
+      :namespace => :metric_namespace,
+      :value => :metric_value
+    }.each do |attr_name, metric_name|
+      _required("metric[#{attr_name}]", attrs[attr_name])
+      metric_attrs[metric_name] = attrs[attr_name].to_s
+    end
+    _expected_length(metric_attrs, 3)
+
+    @result.metric_transformations << metric_attrs
+  end
+end

data/lib/meteorlog/dsl/context.rb

@@ -0,0 +1,45 @@
+class Meteorlog::DSL::Context
+  include Meteorlog::DSL::Validator
+
+  class << self
+    def eval(dsl, path, opts = {})
+      self.new(path, opts) {
+        eval(dsl, binding, path)
+      }
+    end
+  end # of class methods
+
+  attr_reader :result
+
+  def initialize(path, options = {}, &block)
+    @path = path
+    @options = options
+    @result = OpenStruct.new(:log_groups => [])
+    @log_group_names = []
+    instance_eval(&block)
+  end
+
+  private
+
+  def require(file)
+    logsfile = File.expand_path(File.join(File.dirname(@path), file))
+
+    if File.exist?(logsfile)
+      instance_eval(File.read(logsfile), logsfile)
+    elsif File.exist?(logsfile + '.rb')
+      instance_eval(File.read(logsfile + '.rb'), logsfile + '.rb')
+    else
+      Kernel.require(file)
+    end
+  end
+
+  def log_group(name, &block)
+    _required(:log_group_name, name)
+    _validate("LogGroup `#{name}` is already defined") do
+      not @log_group_names.include?(name)
+    end
+
+    @result.log_groups << Meteorlog::DSL::Context::LogGroup.new(name, &block).result
+    @log_group_names << name
+  end
+end

data/lib/meteorlog/dsl/converter.rb

@@ -0,0 +1,78 @@
+class Meteorlog::DSL::Converter
+  class << self
+    def convert(exported, opts = {})
+      self.new(exported, opts).convert
+    end
+  end # of class methods
+
+  def initialize(exported, options = {})
+    @exported = exported
+    @options = options
+  end
+
+  def convert
+    @exported.each.map {|log_group_name, log_group_attrs|
+      output_log_group(log_group_name, log_group_attrs)
+    }.join("\n")
+  end
+
+  private
+
+  def output_log_group(log_group_name, log_group_attrs)
+    log_group_name = log_group_name.inspect
+    buf = []
+    streams = log_group_attrs[:log_streams]
+    buf << output_streams(streams, :prefix => '  ') if streams
+    metric_filters = (log_group_attrs[:metric_filters] || [])
+    buf << output_metric_filters(metric_filters, :prefix => '  ') unless metric_filters.empty?
+
+    <<-EOS
+log_group #{log_group_name} do
+  #{buf.join("\n\n  ")}
+end
+    EOS
+  end
+
+  def output_streams(streams, opts = {})
+    prefix = opts[:prefix]
+
+    streams.map {|stream|
+      "log_stream #{stream.inspect}"
+    }.join("\n#{prefix}")
+  end
+
+  def output_metric_filters(metric_filters, opts = {})
+    prefix = opts[:prefix]
+
+    metric_filters.map {|metric_filter_name, metric_filter_attrs|
+      metric_filter_name = metric_filter_name.inspect
+      filter_pattern = metric_filter_attrs[:filter_pattern]
+      metrics = metric_filter_attrs[:metric_transformations] || []
+
+      buf = []
+      buf << "metric_filter #{metric_filter_name} do"
+      buf << "  filter_pattern #{filter_pattern.inspect}" if filter_pattern
+      buf << "  " + output_metrics(metrics, :prefix => prefix + '  ') unless metrics.empty?
+      buf << "end"
+      buf.join("\n#{prefix}")
+    }.join("\n\n#{prefix}")
+  end
+
+  def output_metrics(metrics, opts = {})
+    prefix = opts[:prefix]
+
+    metrics.map {|metric|
+      metric_attrs = unbrace({
+        :name => metric[:metric_name],
+        :namespace => metric[:metric_namespace],
+        :value => metric[:metric_value],
+      }.inspect)
+
+      "metric #{metric_attrs}"
+    }.join("\n#{prefix}")
+  end
+
+  def unbrace(str)
+    str.sub(/\A\s*\{/, '').sub(/\}\s*\z/, '')
+  end
+end

data/lib/meteorlog/dsl/validator.rb

@@ -0,0 +1,52 @@
+module Meteorlog::DSL::Validator
+  def _required(name, value)
+    invalid = false
+
+    if value
+      case value
+      when String
+        invalid = value.strip.empty?
+      when Array, Hash
+        invalid = value.empty?
+      end
+    elsif value.nil?
+      invalid = true
+    end
+
+    raise _identify("`#{name}` is required") if invalid
+  end
+
+  def _call_once(method_name)
+    @called ||= []
+
+    if @called.include?(method_name)
+      raise _identify("`#{method_name}` is already defined")
+    end
+
+    @called << method_name
+  end
+
+  def _expected_type(value, *types)
+    unless types.any? {|t| value.kind_of?(t) }
+      raise _identify("Invalid type: #{value}")
+    end
+  end
+
+  def _expected_length(value, length)
+    if value.length != length
+      raise _identify("Invalid length: #{value}")
+    end
+  end
+
+  def _validate(errmsg)
+    raise _identify(errmsg) unless yield
+  end
+
+  def _identify(errmsg)
+    if @error_identifier
+      errmsg = "#{@error_identifier}: #{errmsg}"
+    end
+
+    return errmsg
+  end
+end

data/lib/meteorlog/dsl.rb

@@ -0,0 +1,11 @@
+class Meteorlog::DSL
+  class << self
+    def convert(exported, opts = {})
+      Meteorlog::DSL::Converter.convert(exported, opts)
+    end
+
+    def parse(dsl, path, opts = {})
+      Meteorlog::DSL::Context.eval(dsl, path, opts).result
+    end
+  end # of class methods
+end

data/lib/meteorlog/exporter.rb

@@ -0,0 +1,68 @@
+class Meteorlog::Exporter
+  class << self
+    def export(cloud_watch_logs, opts = {})
+      self.new(cloud_watch_logs, opts).export
+    end
+  end # of class methods
+
+  def initialize(cloud_watch_logs, options = {})
+    @cloud_watch_logs = cloud_watch_logs
+    @options = options
+  end
+
+  def export
+    result = {}
+
+    log_groups = @cloud_watch_logs.describe_log_groups.each.inject([]) {|r, i| r + i.log_groups }
+
+    log_groups.each do |log_group|
+      export_log_graoup(log_group, result)
+    end
+
+    return result
+  end
+
+  private
+
+  def export_log_graoup(log_group, result)
+    log_group_name = log_group.log_group_name
+    log_streams = @cloud_watch_logs.describe_log_streams(
+      :log_group_name => log_group_name).log_streams
+    metric_filters = @cloud_watch_logs.describe_metric_filters(
+      :log_group_name => log_group_name).metric_filters
+
+    result[log_group_name] = {
+      :log_streams => export_log_streams(log_streams),
+      :metric_filters => export_metric_filters(metric_filters)
+    }
+  end
+
+  def export_log_streams(log_streams)
+    log_streams.map {|log_stream| log_stream.log_stream_name }
+  end
+
+  def export_metric_filters(metric_filters)
+    result = {}
+
+    metric_filters.each do |metric_filter|
+      filter_name = metric_filter.filter_name
+      metric_transformations = metric_filter.metric_transformations.map do |metric_transformation|
+        {
+          :metric_namespace => metric_transformation.metric_namespace,
+          :metric_name => metric_transformation.metric_name,
+          :metric_value => metric_transformation.metric_value,
+        }
+      end
+
+      result[filter_name] = {
+        :metric_transformations => metric_transformations
+      }
+
+      if metric_filter.filter_pattern
+        result[filter_name][:filter_pattern] = metric_filter.filter_pattern
+      end
+    end
+
+    return result
+  end
+end

data/lib/meteorlog/ext/string_ext.rb

@@ -0,0 +1,25 @@
+class String
+  @@colorize = false
+
+  class << self
+    def colorize=(value)
+      @@colorize = value
+    end
+
+    def colorize
+      @@colorize
+    end
+  end # of class methods
+
+  Term::ANSIColor::Attribute.named_attributes.map do |attribute|
+    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def #{attribute.name}
+        if @@colorize
+          Term::ANSIColor.send(#{attribute.name.inspect}, self)
+        else
+          self
+        end
+      end
+    EOS
+  end
+end

data/lib/meteorlog/logger.rb

@@ -0,0 +1,27 @@
+class Meteorlog::Logger < ::Logger
+  include Singleton
+
+  def initialize
+    super($stdout)
+
+    self.formatter = proc do |severity, datetime, progname, msg|
+      "#{msg}\n"
+    end
+
+    self.level = Logger::INFO
+  end
+
+  def set_debug(value)
+    self.level = value ? Logger::DEBUG : Logger::INFO
+  end
+
+  module Helper
+    def log(level, message, color, log_id = nil)
+      message = "[#{level.to_s.upcase}] #{message}" unless level == :info
+      message << ": #{log_id}" if log_id
+      message << ' (dry-run)' if @options && @options[:dry_run]
+      logger = (@options && @options[:logger]) || Meteorlog::Logger.instance
+      logger.send(level, message.send(color))
+    end
+  end
+end

data/lib/meteorlog/utils.rb

@@ -0,0 +1,25 @@
+module Meteorlog::Utils
+  def collect_to_hash(collection, *key_attrs)
+    opts = key_attrs.last.kind_of?(Hash) ? key_attrs.pop : {}
+    hash = {}
+
+    collection.each do |item|
+      if block_given?
+        key = yield(item)
+      else
+        key = key_attrs.map {|k| item.send(k) }
+        key = key.first if key_attrs.length == 1
+      end
+
+      if opts[:has_many]
+        hash[key] ||= []
+        hash[key] << item
+      else
+        hash[key] = item
+      end
+    end
+
+    return hash
+  end
+  module_function :collect_to_hash
+end

data/lib/meteorlog/version.rb

@@ -0,0 +1,3 @@
+module Meteorlog
+  VERSION = '0.0.1'
+end

data/lib/meteorlog/wrapper/cloud_watch_logs.rb

@@ -0,0 +1,17 @@
+class Meteorlog::Wrapper::CloudWatchLogs
+  def initialize(cloud_watch_logs, options = {})
+    @cloud_watch_logs = cloud_watch_logs
+    @options = options.dup
+  end
+
+  def log_groups
+    Meteorlog::Wrapper::LogGroupCollection.new(
+      @cloud_watch_logs,
+      @cloud_watch_logs.describe_log_groups.each.inject([]) {|r, i| r + i.log_groups },
+      @options)
+  end
+
+  def modified?
+    !!@options[:modified]
+  end
+end

data/lib/meteorlog/wrapper/log_group.rb

@@ -0,0 +1,47 @@
+class Meteorlog::Wrapper::LogGroup
+  extend Forwardable
+  include Meteorlog::Logger::Helper
+
+  def_delegator :@log_group, :log_group_name
+
+  def initialize(cloud_watch_logs, log_group, options = {})
+    @cloud_watch_logs = cloud_watch_logs
+    @log_group = log_group
+    @options = options
+  end
+
+  def log_streams
+    if @log_group.respond_to?(:log_streams)
+      lss = @log_group.log_streams
+    else
+      lss = @cloud_watch_logs.describe_log_streams(
+        :log_group_name => log_group_name
+      ).each.inject([]) {|r, i| r + i.log_streams }
+    end
+
+    Meteorlog::Wrapper::LogStreamCollection.new(
+      @cloud_watch_logs, lss, @log_group, @options)
+  end
+
+  def metric_filters
+    if @log_group.respond_to?(:metric_filters)
+      mfs = @log_group.metric_filters
+    else
+      mfs = @cloud_watch_logs.describe_metric_filters(
+        :log_group_name => log_group_name
+      ).each.inject([]) {|r, i| r + i.metric_filters }
+    end
+
+    Meteorlog::Wrapper::MetricFilterCollection.new(
+      @cloud_watch_logs, mfs, @log_group, @options)
+  end
+
+  def delete
+    log(:info, 'Delete LogGroup', :red, self.log_group_name)
+
+    unless @options[:dry_run]
+      @cloud_watch_logs.delete_log_group(:log_group_name => self.log_group_name)
+      @options[:modified] = true
+    end
+  end
+end

data/lib/meteorlog/wrapper/log_group_collection.rb

@@ -0,0 +1,31 @@
+class Meteorlog::Wrapper::LogGroupCollection
+  include Meteorlog::Logger::Helper
+
+  def initialize(cloud_watch_logs, log_groups, options = {})
+    @cloud_watch_logs = cloud_watch_logs
+    @log_groups = log_groups
+    @options = options
+  end
+
+  def each
+    @log_groups.each do |log_group|
+      yield(Meteorlog::Wrapper::LogGroup.new(
+        @cloud_watch_logs, log_group, @options))
+    end
+  end
+
+  def create(name, opts = {})
+    log(:info, 'Create LogGroup', :cyan, name)
+
+    unless @options[:dry_run]
+      @cloud_watch_logs.create_log_group(:log_group_name => name)
+      @options[:modified] = true
+    end
+
+    log_group = OpenStruct.new(
+      :log_group_name => name, :log_streams => [], :metric_filters => [])
+
+    Meteorlog::Wrapper::LogGroup.new(
+      @cloud_watch_logs, log_group, @options)
+  end
+end

data/lib/meteorlog/wrapper/log_stream.rb

@@ -0,0 +1,25 @@
+class Meteorlog::Wrapper::LogStream
+  extend Forwardable
+  include Meteorlog::Logger::Helper
+
+  def_delegator :@log_stream, :log_stream_name
+  def_delegator :@log_group, :log_group_name
+
+  def initialize(cloud_watch_logs, log_stream, log_group, options = {})
+    @cloud_watch_logs = cloud_watch_logs
+    @log_stream = log_stream
+    @log_group = log_group
+    @options = options
+  end
+
+  def delete
+    log(:info, 'Delete LogStream', :red, "#{self.log_group_name} > #{self.log_stream_name}")
+
+    unless @options[:dry_run]
+      @cloud_watch_logs.delete_log_stream(
+        :log_group_name => self.log_group_name,
+        :log_stream_name => self.log_stream_name)
+      @options[:modified] = true
+    end
+  end
+end

data/lib/meteorlog/wrapper/log_stream_collection.rb

@@ -0,0 +1,36 @@
+class Meteorlog::Wrapper::LogStreamCollection
+  extend Forwardable
+  include Meteorlog::Logger::Helper
+
+  def_delegator :@log_group, :log_group_name
+
+  def initialize(cloud_watch_logs, log_streams, log_group, options = {})
+    @cloud_watch_logs = cloud_watch_logs
+    @log_streams = log_streams
+    @log_group = log_group
+    @options = options
+  end
+
+  def each
+    @log_streams.each do |log_stream|
+      yield(Meteorlog::Wrapper::LogStream.new(
+        @cloud_watch_logs, log_stream, @log_group, @options))
+    end
+  end
+
+  def create(name, opts = {})
+    log(:info, 'Create LogStream', :cyan, "#{self.log_group_name} > #{name}")
+
+    unless @options[:dry_run]
+      @cloud_watch_logs.create_log_stream(
+        :log_group_name => self.log_group_name,
+        :log_stream_name => name)
+      @options[:modified] = true
+    end
+
+    log_stream = OpenStruct.new(:log_stream_name => name)
+
+    Meteorlog::Wrapper::LogStream.new(
+      @cloud_watch_logs, log_stream, @log_group, @options)
+  end
+end

data/lib/meteorlog/wrapper/metric_filter.rb

@@ -0,0 +1,80 @@
+class Meteorlog::Wrapper::MetricFilter
+  extend Forwardable
+  include Meteorlog::Logger::Helper
+
+  DEFAULT_VALUES = {}
+
+  def_delegators :@metric_filter,
+    :filter_name, :filter_pattern, :metric_transformations
+  def_delegator :@log_group, :log_group_name
+
+  def initialize(cloud_watch_logs, metric_filter, log_group, options = {})
+    @cloud_watch_logs = cloud_watch_logs
+    @metric_filter = metric_filter
+    @log_group = log_group
+    @options = options
+  end
+
+  def eql?(dsl)
+    diff(dsl).empty?
+  end
+
+  def update(dsl)
+    delta = diff(dsl)
+    log(:info, 'Update MetricFilter', :green, "#{self.log_group_name} > #{self.filter_name}: #{format_delta(delta)}")
+
+    unless @options[:dry_run]
+      @cloud_watch_logs.put_metric_filter(
+        :log_group_name => self.log_group_name,
+        :filter_name => self.filter_name,
+        :filter_pattern => dsl[:filter_pattern] || '',
+        :metric_transformations => dsl[:metric_transformations])
+      @options[:modified] = true
+    end
+  end
+
+  def delete
+    log(:info, 'Delete MetricFilter', :red, "#{self.log_group_name} > #{self.filter_name}")
+
+    unless @options[:dry_run]
+      @cloud_watch_logs.delete_metric_filter(
+        :log_group_name => self.log_group_name,
+        :filter_name => self.filter_name)
+      @options[:modified] = true
+    end
+  end
+
+  private
+
+  def diff(dsl)
+    delta = {}
+
+    [
+      [:filter_pattern, self.filter_pattern, dsl[:filter_pattern]],
+      [:metric_transformations,
+        self.metric_transformations.map {|i| i.to_h }, dsl[:metric_transformations]],
+    ].each do |name, self_value, dsl_value|
+      if normalize(name, self_value) != normalize(name, dsl_value)
+        delta[name] = {:old => self_value, :new => dsl_value}
+      end
+    end
+
+    return delta
+  end
+
+  def format_delta(delta)
+    delta.map {|name, values|
+      "#{name}(#{values[:old].inspect}=>#{values[:new].inspect})"
+    }.join(', ')
+  end
+
+  def normalize(name, value)
+    if [Array, Hash].any? {|c| value.kind_of?(c) }
+      value.sort
+    elsif DEFAULT_VALUES.has_key?(name) and value.nil?
+      DEFAULT_VALUES[name]
+    else
+      value
+    end
+  end
+end

data/lib/meteorlog/wrapper/metric_filter_collection.rb

@@ -0,0 +1,40 @@
+class Meteorlog::Wrapper::MetricFilterCollection
+  extend Forwardable
+  include Meteorlog::Logger::Helper
+
+  def_delegator :@log_group, :log_group_name
+
+  def initialize(cloud_watch_logs, metric_filters, log_group, options = {})
+    @cloud_watch_logs = cloud_watch_logs
+    @metric_filters = metric_filters
+    @log_group = log_group
+    @options = options
+  end
+
+  def each
+    @metric_filters.each do |metric_filter|
+      yield(Meteorlog::Wrapper::MetricFilter.new(
+        @cloud_watch_logs, metric_filter, @log_group, @options))
+    end
+  end
+
+  def create(name, opts = {})
+    log(:info, 'Create MetricFilter', :cyan, "#{self.log_group_name} > #{name}")
+
+    unless @options[:dry_run]
+      @cloud_watch_logs.put_metric_filter(
+        :log_group_name => self.log_group_name,
+        :filter_name => name,
+        :filter_pattern => opts[:filter_pattern] || '',
+        :metric_transformations => opts[:metric_transformations])
+      @options[:modified] = true
+    end
+
+    metric_filter = OpenStruct.new(
+      :filter_name => name,
+      :filter_pattern => opts[:filter_pattern],
+      :metric_transformations => opts[:metric_transformations])
+
+    Meteorlog::Wrapper::MetricFilter.new(metric_filter, @log_group, @options)
+  end
+end

data/lib/meteorlog/wrapper.rb

@@ -0,0 +1,7 @@
+class Meteorlog::Wrapper
+  class << self
+    def wrap(cwl, opts = {})
+      Meteorlog::Wrapper::CloudWatchLogs.new(cwl, opts)
+    end
+  end # of class methods
+end

data/lib/meteorlog.rb

@@ -0,0 +1,31 @@
+module Meteorlog; end
+
+require 'forwardable'
+require 'json'
+require 'logger'
+require 'ostruct'
+require 'singleton'
+
+require 'aws-sdk-core'
+require 'term/ansicolor'
+
+require 'meteorlog/logger'
+require 'meteorlog/utils'
+require 'meteorlog/client'
+require 'meteorlog/dsl'
+require 'meteorlog/dsl/validator'
+require 'meteorlog/dsl/context'
+require 'meteorlog/dsl/context/log_group'
+require 'meteorlog/dsl/context/metric_filter'
+require 'meteorlog/dsl/converter'
+require 'meteorlog/exporter'
+require 'meteorlog/ext/string_ext'
+require 'meteorlog/version'
+require 'meteorlog/wrapper'
+require 'meteorlog/wrapper/cloud_watch_logs'
+require 'meteorlog/wrapper/log_group'
+require 'meteorlog/wrapper/log_group_collection'
+require 'meteorlog/wrapper/log_stream'
+require 'meteorlog/wrapper/log_stream_collection'
+require 'meteorlog/wrapper/metric_filter'
+require 'meteorlog/wrapper/metric_filter_collection'

data/meteorlog.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'meteorlog/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'meteorlog'
+  spec.version       = Meteorlog::VERSION
+  spec.authors       = ['Genki Sugawara']
+  spec.email         = ['sgwr_dts@yahoo.co.jp']
+  spec.description   = "Meteorlog is a tool to manage CloudWatch Logs. It defines the state of CloudWatch Logs using DSL, and updates CloudWatch Logs according to DSL."
+  spec.summary       = "Meteorlog is a tool to manage CloudWatch Logs."
+  spec.homepage      = 'https://github.com/winebarrel/meteorlog'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'aws-sdk-core', '>= 2.0.0.rc8'
+  spec.add_dependency "json"
+  spec.add_dependency "term-ansicolor"
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '>= 3.0.0'
+end

data/spec/meteorlog_spec.rb

@@ -0,0 +1,5 @@
+describe Meteorlog do
+  it do
+    expect(1).to eq(1)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'meteorlog'

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: meteorlog
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Genki Sugawara
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.rc8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.rc8
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Meteorlog is a tool to manage CloudWatch Logs. It defines the state of
+  CloudWatch Logs using DSL, and updates CloudWatch Logs according to DSL.
+email:
+- sgwr_dts@yahoo.co.jp
+executables:
+- meteorlog
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/meteorlog
+- lib/meteorlog.rb
+- lib/meteorlog/client.rb
+- lib/meteorlog/dsl.rb
+- lib/meteorlog/dsl/context.rb
+- lib/meteorlog/dsl/context/log_group.rb
+- lib/meteorlog/dsl/context/metric_filter.rb
+- lib/meteorlog/dsl/converter.rb
+- lib/meteorlog/dsl/validator.rb
+- lib/meteorlog/exporter.rb
+- lib/meteorlog/ext/string_ext.rb
+- lib/meteorlog/logger.rb
+- lib/meteorlog/utils.rb
+- lib/meteorlog/version.rb
+- lib/meteorlog/wrapper.rb
+- lib/meteorlog/wrapper/cloud_watch_logs.rb
+- lib/meteorlog/wrapper/log_group.rb
+- lib/meteorlog/wrapper/log_group_collection.rb
+- lib/meteorlog/wrapper/log_stream.rb
+- lib/meteorlog/wrapper/log_stream_collection.rb
+- lib/meteorlog/wrapper/metric_filter.rb
+- lib/meteorlog/wrapper/metric_filter_collection.rb
+- meteorlog.gemspec
+- spec/meteorlog_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/winebarrel/meteorlog
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Meteorlog is a tool to manage CloudWatch Logs.
+test_files:
+- spec/meteorlog_spec.rb
+- spec/spec_helper.rb