mackerel-client 0.3.0 → 0.4.0

data/lib/mackerel/client.rb

@@ -2,13 +2,39 @@ require 'faraday'
 require 'uri'
 
 require 'json' unless defined? ::JSON
+
+require 'mackerel/role'
 require 'mackerel/host'
+require 'mackerel/monitor'
+require 'mackerel/monitoring'
+require 'mackerel/service'
+require 'mackerel/alert'
+require 'mackerel/annotation'
+require 'mackerel/user'
+require 'mackerel/invitation'
+require 'mackerel/organization'
+require 'mackerel/dashboard'
+require 'mackerel/metric'
+require 'mackerel/metadata'
+require 'mackerel/notification_group'
+require 'mackerel/channel'
 
 module Mackerel
-
   class Client
-
-    ERROR_MESSAGE_FOR_API_KEY_ABSENCE = "API key is absent. Set your API key in a environment variable called MACKEREL_APIKEY."
+    include Mackerel::REST::Alert
+    include Mackerel::REST::Annotation
+    include Mackerel::REST::Dashboard
+    include Mackerel::REST::Host
+    include Mackerel::REST::Invitation
+    include Mackerel::REST::Metric
+    include Mackerel::REST::Monitor
+    include Mackerel::REST::Monitoring
+    include Mackerel::REST::Organization
+    include Mackerel::REST::Service
+    include Mackerel::REST::User
+    include Mackerel::REST::Metadata
+    include Mackerel::REST::Channel
+    include Mackerel::REST::NotificationGroup
 
     def initialize(args = {})
       @origin       = args[:mackerel_origin]  || 'https://api.mackerelio.com'
@@ -17,156 +43,8 @@ module Mackerel
       @open_timeout = args[:open_timeout]     || 30 # Ref: apiRequestTimeout at mackerel-agent
     end
 
-    def post_host(host)
-      response = client.post "/api/v0/hosts" do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-        req.body = host.to_json
-      end
-
-      unless response.success?
-        raise "POST /api/v0/hosts failed: #{response.status}"
-      end
-
-      data = JSON.parse(response.body)
-    end
-
-    def get_host(host_id)
-      response = client.get "/api/v0/hosts/#{host_id}" do |req|
-        req.headers['X-Api-Key'] = @api_key
-      end
-
-      unless response.success?
-        raise "GET /api/v0/hosts/#{host_id} failed: #{response.status}"
-      end
-
-      data = JSON.parse(response.body)
-      Host.new(data['host'])
-    end
-
-    def update_host_status(host_id, status)
-      unless [:standby, :working, :maintenance, :poweroff].include?(status.to_sym)
-        raise "no such status: #{status}"
-      end
-
-      response = client.post "/api/v0/hosts/#{host_id}/status" do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-        req.body = { "status" => status }.to_json
-      end
-
-      unless response.success?
-        raise "POST /api/v0/hosts/#{host_id}/status failed: #{response.status}"
-      end
-
-      data = JSON.parse(response.body)
-    end
-
-    def retire_host(host_id)
-      response = client.post "/api/v0/hosts/#{host_id}/retire" do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-        req.body = { }.to_json
-      end
-
-      unless response.success?
-        raise "POST /api/v0/hosts/#{host_id}/retire failed: #{response.status}"
-      end
-
-      data = JSON.parse(response.body)
-    end
-
-    def post_metrics(metrics)
-      response = client.post '/api/v0/tsdb' do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-        req.body = metrics.to_json
-      end
-
-      unless response.success?
-        raise "POST /api/v0/tsdb failed: #{response.status}"
-      end
-
-      data = JSON.parse(response.body)
-    end
-
-    def get_latest_metrics(hostIds, names)
-      query = (hostIds.map{ |hostId| "hostId=#{hostId}" } +
-               names.map{ |name| "name=#{name}" }).join('&')
-
-      response = client.get "/api/v0/tsdb/latest?#{query}" do |req|
-        req.headers['X-Api-Key'] = @api_key
-      end
-
-      unless response.success?
-        raise "/api/v0/tsdb/latest?#{query} failed: #{response.status}"
-      end
-
-      data = JSON.parse(response.body)
-      data["tsdbLatest"]
-    end
-
-    def post_service_metrics(service_name, metrics)
-      response = client.post "/api/v0/services/#{service_name}/tsdb" do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-        req.body = metrics.to_json
-      end
-
-      unless response.success?
-        raise "POST /api/v0/services/#{service_name}/tsdb failed: #{response.status}"
-      end
-
-      data = JSON.parse(response.body)
-    end
-
-    def define_graphs(graph_defs)
-      response = client.post '/api/v0/graph-defs/create' do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-        req.body = graph_defs.to_json
-      end
-
-      unless response.success?
-        raise "POST /api/v0/graph-defs/create failed: #{response.status} #{response.body}"
-      end
-
-      JSON.parse(response.body)
-    end
-
-    def get_hosts(opts = {})
-      response = client.get '/api/v0/hosts' do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.params['service']          = opts[:service]          if opts[:service]
-        req.params['role']             = opts[:roles]            if opts[:roles]
-        req.params['name']             = opts[:name]             if opts[:name]
-        req.params['status']           = opts[:status]           if opts[:status]
-        req.params['customIdentifier'] = opts[:customIdentifier] if opts[:customIdentifier]
-      end
-
-      unless response.success?
-        raise "GET /api/v0/hosts failed: #{response.status}"
-      end
-
-      data = JSON.parse(response.body)
-      data['hosts'].map{ |host_json| Host.new(host_json) }
-    end
-
-    def post_graph_annotation(annotation)
-      response = client.post '/api/v0/graph-annotations' do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-        req.body = annotation.to_json
-      end
-
-      unless response.success?
-        raise "POST /api/v0/graph-annotations failed: #{response.status} #{response.body}"
-      end
-
-      JSON.parse(response.body)
-    end
-
     private
+    ERROR_MESSAGE_FOR_API_KEY_ABSENCE = "API key is absent. Set your API key in a environment variable called MACKEREL_APIKEY."
 
     def client
       @client ||= http_client
@@ -181,7 +59,5 @@ module Mackerel
         faraday.options.open_timeout   = @open_timeout
       end
     end
-
   end
-
 end

data/lib/mackerel/dashboard.rb

@@ -0,0 +1,71 @@
+module Mackerel
+
+  class Dashboard
+    attr_accessor :id, :title, :bodyMarkdown, :urlPath, :createdAt, :updatedAt
+    def initialize(args = {})
+      @id                              = args["id"]
+      @title                           = args["title"]
+      @bodyMarkdown                    = args["bodyMarkdown"]
+      @urlPath                         = args["urlPath"]
+      @createdAt                       = args["createdAt"]
+      @updatedAt                       = args["updatedAt"]
+    end
+
+    def to_h
+      instance_variables.flat_map do |name|
+        respond_to?(name[1..-1]) ? [name[1..-1]] : []
+      end.each_with_object({}) do |name, hash|
+        hash[name] = public_send(name)
+      end.delete_if { |key, val| val == nil }
+    end
+
+    def to_json(options = nil)
+      return to_h.to_json(options)
+    end
+
+  end
+
+  module REST
+    module Dashboard
+      def post_dashboard(title, markdown, urlPath)
+        command = ApiCommand.new(:post, '/api/v0/dashboards', @api_key)
+        command.body = {
+            title: title,
+            bodyMarkdown: markdown,
+            urlPath: urlPath
+        }.to_json
+        data = command.execute(client)
+        Mackerel::Dashboard.new(data)
+      end
+
+      def update_dashboard(dashboardId, title, markdown, urlPath)
+        command = ApiCommand.new(:put, "/api/v0/dashboards/#{dashboardId}", @api_key)
+        command.body = {
+            title: title,
+            bodyMarkdown: markdown,
+            urlPath: urlPath
+        }.to_json
+        data = command.execute(client)
+        Mackerel::Dashboard.new(data)
+      end
+
+      def get_dashboards()
+        command = ApiCommand.new(:get, '/api/v0/dashboards', @api_key)
+        data = command.execute(client)
+        data['dashboards'].map{ |d| Mackerel::Dashboard.new(d) }
+      end
+
+      def get_dashboard(dashboardId)
+        command = ApiCommand.new(:get, "/api/v0/dashboards/#{dashboardId}", @api_key)
+        data = command.execute(client)
+        Mackerel::Dashboard.new(data)
+      end
+
+      def delete_dashboard(dashboardId)
+        command = ApiCommand.new(:delete, "/api/v0/dashboards/#{dashboardId}", @api_key)
+        data = command.execute(client)
+        Mackerel::Dashboard.new(data)
+      end
+    end
+  end
+end

data/lib/mackerel/host.rb

@@ -39,4 +39,66 @@ module Mackerel
     end
   end
 
+  module REST
+    module Host
+
+      def post_host(host)
+        command = ApiCommand.new(:post, "/api/v0/hosts", @api_key)
+        command.body = host.to_json
+        data = command.execute(client)
+      end
+
+      def update_host(host_id, host)
+        command = ApiCommand.new(:put, "/api/v0/hosts/#{host_id}", @api_key)
+        command.body = host.to_json
+        data = command.execute(client)
+      end
+
+      def update_host_roles(host_id, roles)
+        roles = [roles] if roles.is_a?(String)
+        command = ApiCommand.new(:put, "/api/v0/hosts/#{host_id}/role-fullnames", @api_key)
+        command.body = { "roleFullnames" => roles }.to_json
+        data = command.execute(client)
+      end
+
+      def get_host(host_id)
+        command = ApiCommand.new(:get, "/api/v0/hosts/#{host_id}", @api_key)
+        data = command.execute(client)
+        Mackerel::Host.new(data['host'])
+      end
+
+      def update_host_status(host_id, status)
+        unless [:standby, :working, :maintenance, :poweroff].include?(status.to_sym)
+          raise "no such status: #{status}"
+        end
+  
+        command = ApiCommand.new(:post, "/api/v0/hosts/#{host_id}/status", @api_key)
+        command.body = { "status" => status }.to_json
+        data = command.execute(client)
+      end
+
+      def retire_host(host_id)
+        command = ApiCommand.new(:post, "/api/v0/hosts/#{host_id}/retire", @api_key)
+        command.body = { }.to_json
+        data = command.execute(client)
+      end
+
+      def get_hosts(opts = {})
+        command = ApiCommand.new(:get, '/api/v0/hosts', @api_key)
+        command.params['service']          = opts[:service] if opts[:service]
+        command.params['role']             = opts[:roles]   if opts[:roles]
+        command.params['name']             = opts[:name]    if opts[:name]
+        command.params['status']           = opts[:status]  if opts[:status]
+        command.params['customIdentifier'] = opts[:customIdentifier] if opts[:customIdentifier]
+        data = command.execute(client)
+        data['hosts'].map{ |host_json| Mackerel::Host.new(host_json) }
+      end
+
+      def get_host_metric_names(host_id)
+        command = ApiCommand.new(:get, "/api/v0/hosts/#{host_id}/metric-names", @api_key)
+        data = command.execute(client)
+        data["names"]
+      end
+    end
+  end
 end

data/lib/mackerel/invitation.rb

@@ -0,0 +1,20 @@
+module Mackerel
+  module REST
+    module Invitation
+      def post_invitation(email, authority)
+        command = ApiCommand.new(:post, '/api/v0/invitations', @api_key)
+        command.body = { 
+          email: email.to_s,
+          authority: authority.to_s
+        }.to_json
+        data = command.execute(client)
+      end
+
+      def revoke_invitation(email)
+        command = ApiCommand.new(:post, '/api/v0/invitations/revoke', @api_key)
+        command.body = { email: email.to_s }.to_json
+        data = command.execute(client)
+      end
+    end
+  end
+end

data/lib/mackerel/metadata.rb

@@ -1,58 +1,26 @@
 module Mackerel
-
-  class Client
-
-    def list_metadata(host_id)
-      response = client.get "/api/v0/hosts/#{host_id}/metadata" do |req|
-        req.headers['X-Api-Key'] = @api_key
+  module REST
+    module Metadata
+      def get_metadata(host_id, namespace)
+        command = ApiCommand.new(:get, "/api/v0/hosts/#{host_id}/metadata/#{namespace}", @api_key)
+        data = command.execute(client)
       end
 
-      unless response.success?
-        raise "GET /api/v0/hosts/#{host_id}/metadata failed: #{response.status} #{response.body}"
+      def list_metadata(host_id)
+        command = ApiCommand.new(:get, "/api/v0/hosts/#{host_id}/metadata", @api_key)
+        data = command.execute(client)
       end
 
-      JSON.parse(response.body)
-    end
-
-    def get_metadata(host_id, namespace)
-      response = client.get "/api/v0/hosts/#{host_id}/metadata/#{namespace}" do |req|
-        req.headers['X-Api-Key'] = @api_key
+      def update_metadata(host_id, namespace, metadata)
+        command = ApiCommand.new(:put, "/api/v0/hosts/#{host_id}/metadata/#{namespace}", @api_key)
+        command.body = metadata.to_json
+        data = command.execute(client)
       end
 
-      unless response.success?
-        raise "GET /api/v0/hosts/#{host_id}/metadata/#{namespace} failed: #{response.status} #{response.body}"
+      def delete_metadata(host_id, namespace)
+        command = ApiCommand.new(:delete, "/api/v0/hosts/#{host_id}/metadata/#{namespace}", @api_key)
+        data = command.execute(client)
       end
-
-      JSON.parse(response.body)
     end
-
-    def update_metadata(host_id, namespace, data)
-      response = client.put "/api/v0/hosts/#{host_id}/metadata/#{namespace}" do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-        req.body = data.to_json
-      end
-
-      unless response.success?
-        raise "PUT /api/v0/hosts/#{host_id}/metadata/#{namespace} failed: #{response.status} #{response.body}"
-      end
-
-      JSON.parse(response.body)
-    end
-
-    def delete_metadata(host_id, namespace)
-      response = client.delete "/api/v0/hosts/#{host_id}/metadata/#{namespace}" do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-      end
-
-      unless response.success?
-        raise "DELETE /api/v0/hosts/#{host_id}/metadata/#{namespace} failed: #{response.status} #{response.body}"
-      end
-
-      JSON.parse(response.body)
-    end
-
   end
-
 end

data/lib/mackerel/metric.rb

@@ -0,0 +1,50 @@
+module Mackerel
+  module REST
+    module Metric
+      def post_metrics(metrics)
+        command = ApiCommand.new(:post, '/api/v0/tsdb', @api_key)
+        command.body = metrics.to_json
+        data = command.execute(client)
+      end
+
+      def get_host_metrics(host_id, name, from, to)
+        command = ApiCommand.new(:get, "/api/v0/hosts/#{host_id}/metrics", @api_key)
+        command.params['name'] = name
+        command.params['from'] = from
+        command.params['to'] = to
+        data = command.execute(client)
+        data["metrics"]
+      end
+
+      def get_latest_metrics(host_id, name)
+        command = ApiCommand.new(:get, "/api/v0/tsdb/latest", @api_key)
+        command.params['hostId'] = host_id
+        command.params['name'] = name
+        data = command.execute(client)
+        data["tsdbLatest"]
+      end
+
+      def post_service_metrics(service_name, metrics)
+        command = ApiCommand.new(:post, "/api/v0/services/#{service_name}/tsdb", @api_key)
+        command.body = metrics.to_json
+        data = command.execute(client)
+      end
+
+      def get_service_metrics(service_name, name, from, to)
+        command = ApiCommand.new(:get, "/api/v0/services/#{service_name}/metrics", @api_key)
+        command.params['name'] = name
+        command.params['from'] = from
+        command.params['to'] = to
+        data = command.execute(client)
+        data["metrics"]
+      end
+
+      def define_graphs(graph_defs)
+        command = ApiCommand.new(:post, '/api/v0/graph-defs/create', @api_key)
+        command.body = graph_defs.to_json
+        data = command.execute(client)
+      end
+    end
+  end
+end
+

data/lib/mackerel/monitor.rb

@@ -32,75 +32,45 @@ module Mackerel
     def to_h
       instance_variables.flat_map do |name|
         respond_to?(name[1..-1]) ? [name[1..-1]] : []
-      end.each_with_object({}) do |name, hash| 
+      end.each_with_object({}) do |name, hash|
         hash[name] = public_send(name)
       end.delete_if { |key, val| val == nil }
     end
 
-    def to_json
-      return to_h.to_json
+    def to_json(options = nil)
+      return to_h.to_json(options)
     end
 
   end
 
-  class Client
+  module REST
+    module Monitor
 
-    def post_monitor(monitor)
-      response = client.post "/api/v0/monitors" do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-        req.body = monitor.to_json
+      def post_monitor(monitor)
+        command = ApiCommand.new(:post, '/api/v0/monitors', @api_key)
+        command.body = monitor.to_json
+        data = command.execute(client)
+        Mackerel::Monitor.new(data)
       end
 
-      unless response.success?
-        raise "POST /api/v0/monitors failed: #{response.status}"
+      def get_monitors()
+        command = ApiCommand.new(:get,'/api/v0/monitors', @api_key)
+        data = command.execute(client)
+        data['monitors'].map{ |m| Mackerel::Monitor.new(m) }
       end
 
-      data = JSON.parse(response.body)
-      Monitor.new(data)
-    end
-
-    def get_monitors()
-      response = client.get '/api/v0/monitors' do |req|
-        req.headers['X-Api-Key'] = @api_key
+      def update_monitor(monitor_id, monitor)
+        command = ApiCommand.new(:put, "/api/v0/monitors/#{monitor_id}", @api_key)
+        command.body = monitor.to_json
+        data = command.execute(client)
+        Mackerel::Monitor.new(data)
       end
 
-      unless response.success?
-        raise "GET /api/v0/monitors failed: #{response.status}"
+      def delete_monitor(monitor_id)
+        command = ApiCommand.new(:delete, "/api/v0/monitors/#{monitor_id}", @api_key)
+        data = command.execute(client)
+        Mackerel::Monitor.new(data)
       end
-
-      data = JSON.parse(response.body)
-      data['monitors'].map{ |monitor_json| Monitor.new(monitor_json) }
-    end
-
-    def update_monitor(monitor_id, monitor)
-      response = client.put "/api/v0/monitors/#{monitor_id}" do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-        req.body = monitor.to_json
-      end
-
-      unless response.success?
-        raise "PUT /api/v0/monitors/#{monitor_id} failed: #{response.status}"
-      end
-
-      JSON.parse(response.body)
     end
-
-    def delete_monitor(monitor_id)
-      response = client.delete "/api/v0/monitors/#{monitor_id}" do |req|
-        req.headers['X-Api-Key'] = @api_key
-        req.headers['Content-Type'] = 'application/json'
-      end
-
-      unless response.success?
-        raise "DELETE /api/v0/monitors/#{monitor_id} failed: #{response.status}"
-      end
-
-      data = JSON.parse(response.body)
-      Monitor.new(data)
-    end
-
   end
-
 end

data/lib/mackerel/monitoring.rb

@@ -0,0 +1,13 @@
+module Mackerel
+  module REST
+    module Monitoring
+
+      def post_monitoring_check_report(reports)
+        command = ApiCommand.new(:post,'/api/v0/monitoring/checks/report', @api_key)
+        command.body = reports.to_json
+        data = command.execute(client)
+      end
+
+    end
+  end
+end

data/lib/mackerel/notification_group.rb

@@ -0,0 +1,58 @@
+module Mackerel
+
+  class NotificationGroup
+    attr_accessor :id, :name, :notificationLevel, :childNotificationGroupIds, :childChannelIds, :monitors, :services
+    def initialize(args = {})
+      @id                              = args["id"]
+      @name                            = args["name"]
+      @notificationLevel               = args["notificationLevel"]
+      @childNotificationGroupIds       = args["childNotificationGroupIds"]
+      @childChannelIds                 = args["childChannelIds"]
+      @monitors                        = args["monitors"]
+      @services                        = args["services"]
+    end
+
+    def to_h
+      instance_variables.flat_map do |name|
+        respond_to?(name[1..-1]) ? [name[1..-1]] : []
+      end.each_with_object({}) do |name, hash|
+        hash[name] = public_send(name)
+      end.delete_if { |key, val| val == nil }
+    end
+
+    def to_json(options = nil)
+      return to_h.to_json(options)
+    end
+
+  end
+
+  module REST
+    module NotificationGroup
+      def post_notification_group(notification_group)
+        command = ApiCommand.new(:post, '/api/v0/notification-groups', @api_key)
+        command.body = notification_group.to_json
+        data = command.execute(client)
+        Mackerel::NotificationGroup.new(data)
+      end
+  
+      def get_notification_groups()
+        command = ApiCommand.new(:get, '/api/v0/notification-groups', @api_key)
+        data = command.execute(client)
+        data['notificationGroups'].map{|a| Mackerel::NotificationGroup.new(a)}
+      end
+  
+      def update_notification_group(notification_group_id, notification_group)
+        command = ApiCommand.new(:put, "/api/v0/notification-groups/#{notification_group_id}", @api_key)
+        command.body = notification_group.to_json
+        data = command.execute(client)
+        Mackerel::NotificationGroup.new(data)
+      end
+  
+      def delete_notification_group(notification_group_id)
+        command = ApiCommand.new(:delete, "/api/v0/notification-groups/#{notification_group_id}", @api_key)
+        data = command.execute(client)
+        Mackerel::NotificationGroup.new(data)
+      end
+    end
+  end
+end