cronitor 1.1.5 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4c234da3ffd469dc74eefc0ee50a369c5c3b967c
-  data.tar.gz: c89a778d71c9b27463777699eed0b2fc21a2cd12
+SHA256:
+  metadata.gz: d91bccffc3a53dfe487e4740c00aa83b47fe31c4347a1bdc93e017bbb3467751
+  data.tar.gz: 5730c8a4742bab773c1e3582fa4f00298890171e91ef96b83fda8e0a6ebd6470
 SHA512:
-  metadata.gz: 958007209685433235f3387c29cddbdb6e976c27cf1539bfa5ce2e7fdd58d0e9e8057c6089ba28635005368ae658cb96370a51c9863f338671aff78860f0d38e
-  data.tar.gz: 64db58946e2287628ba325387cccb469a07d7bdd6bffbf965b69111f8c5f7dcd172d5dec0a61588f4e5d94b29c823c23a8394ee89563bb5770553be82b09337e
+  metadata.gz: '054173538e57d465de2cc25786a42ccdb80c2be0532f0526634153de3fd7c46f428cdeaded4dd84e6169a9aa5717439bab0b1b4cc9672b56b93543ae58183ae3'
+  data.tar.gz: 311901851f90644a7d0c46eeed1b2bd821880816090799d1601008e29fa19a4cad2199905f317a9a08225296d579ba054bc87456dadf19fe427f3487c0ac42ce

data/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+---
+name: Publish
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  publish:
+    needs:
+      - lint
+      - test
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby 2.7
+        uses: actions/setup-ruby@v1
+        with:
+          ruby-version: 2.7.x
+      - name: Build and test with Rake
+        run: |
+          gem install bundler
+          bundle install --jobs 4 --retry 3
+          bundle exec rake release
+        with:
+          api_key: ${{secrets.RUBYGEMS_API_KEY}}

data/.github/workflows/test.yml

@@ -0,0 +1,54 @@
+---
+name: Test
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  lint:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - '2.7'
+          - '3.0'
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby 2.7
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run Rubocop
+        run: bundle exec rake rubocop
+
+  spec:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - '2.7'
+          - '3.0'
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby 2.7
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Build and test with Rake
+        run: |
+          gem install bundler
+          bundle install --jobs 4 --retry 3
+          bundle exec rake

data/.rubocop.yml

@@ -0,0 +1,42 @@
+---
+require:
+  - rubocop-rake
+  - rubocop-rspec
+
+inherit_mode:
+  merge:
+    - Exclude
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 2.5
+  Exclude:
+    - 'spec/cronitor_spec.rb'
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/RaiseArgs:
+  EnforcedStyle: compact
+
+Style/EachWithObject:
+  Enabled: false
+

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in cronitor.gemspec

data/README.md

@@ -1,104 +1,222 @@
-# Cronitor
+# Cronitor Ruby Library
 
-[![Travis](https://img.shields.io/travis/evertrue/cronitor.svg)](https://github.com/evertrue/cronitor)
+![Test](https://github.com/cronitorio/cronitor-ruby/workflows/Test/badge.svg)
 [![Gem Version](https://badge.fury.io/rb/cronitor.svg)](https://badge.fury.io/rb/cronitor)
 
-[Cronitor](https://cronitor.io/) is a service for heartbeat-style monitoring of just about anything that can send an HTTP request.
 
-This gem provides a simple abstraction for the creation and pinging of a Cronitor monitor. For a better understanding of the API this gem talks to, please see [How Cronitor Works](https://cronitor.io/help/how-cronitor-works).
+[Cronitor](https://cronitor.io/) provides dead simple monitoring for cron jobs, daemons, queue workers, websites, APIs, and anything else that can send or receive an HTTP request. The Cronitor Ruby library provides convenient access to the Cronitor API from applications written in Ruby. See our [API docs](https://cronitor.io/docs/api) for detailed references on configuring monitors and sending telemetry pings.
+
+In this guide:
+
+- [Installation](##Installation)
+- [Monitoring Background Jobs](##monitoring-background-jobs)
+- [Sending Telemetry Events](##sending-telemetry-events)
+- [Configuring Monitors](##configuring-monitors)
+- [Package Configuration & Env Vars](##package-configuration)
+- [Command Line Usage](##command-line-usage)
+- [Contributing](##contributing)
 
 ## Installation
 
-Add this line to your application's Gemfile:
+```
+gem install cronitor
+```
+
+## Monitoring Background Jobs
+
+The `Cronitor#job` helper will send telemetry events before calling your block and after it exits. If your block raises an exception a `fail` event will be sent (and the exception re-raised).
+
+```ruby
+require 'cronitor'
+Cronitor.api_key = 'api_key_123'
+
+Cronitor.job 'warehouse-replenishmenth-report' do
+  ReplenishmentReport.new(Date.today).run()
+end
+```
+
+### Integrating with Sidekiq
+Cronitor provides a [separate library](https://github.com/cronitorio/cronitor-sidekiq) built with this SDK to make Sidekiq integration even easier.
+
+
+## Sending Telemetry Events
+
+If you want finer control over when/how [telemetry pings](https://cronitor.io/docs/telemetry-api) are sent,
+you can instantiate a monitor and call `#ping`.
 
 ```ruby
-gem 'cronitor'
+require 'cronitor'
+Cronitor.api_key = 'api_key_123'
+
+monitor = Cronitor::Monitor.new('heartbeat-monitor')
+
+monitor.ping # a basic heartbeat event
+
+# optional params can be passed as kwargs
+# complete list - https://cronitor.io/docs/telemetry-api#parameters
+
+monitor.ping(state: 'run', env: 'staging') # a job/process has started in a staging environment
+
+# a job/process has completed - include metrics for cronitor to record
+monitor.ping(state: 'complete', metrics: {count: 1000, error_count: 17})
 ```
 
-And then execute:
+## Configuring Monitors
+
+You can configure all of your monitors using a single YAML file. This can be version controlled and synced to Cronitor as part of
+a deployment or build process. For details on all of the attributes that can be set, see the [Monitor API](https://cronitor.io/docs/monitor-api) documentation.
+
+```ruby
+require 'cronitor'
+Cronitor.api_key = 'api_key_123'
 
-    $ bundle
+# read config file and set credentials (if included).
+Cronitor.read_config('./cronitor.yaml')
 
-Or install it yourself as:
+# sync config file's monitors to Cronitor.
+Cronitor.apply_config
 
-    $ gem install cronitor
+# send config file's monitors to Cronitor to validate correctness.
+# monitors will not be saved.
+Cronitor.validate_config
+```
 
-## Usage
+The `cronitor.yaml` file includes three top level keys `jobs`, `checks`, `events`. You can configure monitors under each key by defining [monitors](https://cronitor.io/docs/monitor-api#attributes).
+
+```yaml
+jobs:
+    nightly-database-backup:
+        schedule: 0 0 * * *
+        notify:
+            - devops-alert-pagerduty
+        assertions:
+            - metric.duration < 5 minutes
+
+    send-welcome-email:
+        schedule: every 10 minutes
+        assertions:
+            - metric.count > 0
+            - metric.duration < 30 seconds
+
+check:
+    cronitor-homepage:
+        request:
+            url: https://cronitor.io
+            regions:
+                - us-east-1
+                - eu-central-1
+                - ap-northeast-1
+        assertions:
+            - response.code = 200
+            - response.time < 2s
+
+    cronitor-telemetry-api:
+        request:
+            url: https://cronitor.link/ping
+        assertions:
+            - response.body contains ok
+            - response.time < .25s
+
+heartbeats:
+    production-deploy:
+        notify:
+            alerts: ['deploys-slack']
+            events: true # send alert when the event occurs
 
-### Creating a Monitor
+```
 
-A Cronitor monitor (hereafter referred to only as a monitor for brevity) is created if it does not already exist, and its ID returned.
+You can also create and update monitors by calling `Monitor.put`.
 
 ```ruby
 require 'cronitor'
 
-monitor_options = {
-  name: 'My Fancy Monitor',
-  notifications: {
-    emails: ['test@example.com'],
-    slack: [],
-    pagerduty: [],
-    phones: [],
-    webhooks: []
+monitors = Cronitor::Monitor.put([
+  {
+    type: 'job',
+    key: 'send-customer-invoices',
+    schedule: '0 0 * * *',
+    assertions: [
+        'metric.duration < 5 min'
+    ],
+    notify: ['devops-alerts-slack']
   },
-  rules: [
-    {
-      rule_type: 'not_run_in',
-      duration: 5
-      rime_unit: 'seconds'
-    }
-  ],
-  note: 'A human-friendly description of this monitor'
-}
-my_monitor = Cronitor.new token: 'api_token', opts: monitor_options
+  {
+    type: 'check',
+    key: 'Cronitor Homepage',
+    request: {
+        url: 'https://cronitor.io'
+    },
+    schedule: 'every 45 seconds',
+    assertions: [
+        'response.code = 200',
+        'response.time < 600ms',
+    ]
+  }
+])
 ```
 
-You may optionally specify a `:human_readable` value for your rule(s), otherwise one will be crafted for you:
+### Pause, Reset, Delete
 
 ```ruby
-monitor_options = {
-  rules: [
-    {
-      rule_type: 'not_run_in',
-      duration: 5
-      time_unit: 'seconds',
-      human_readable: 'not_run_in 5 seconds'
-    }
-  ],
+require 'cronitor'
+
+monitor = Cronitor::Monitor.new('heartbeat-monitor')
+
+monitor.pause(24) # pause alerting for 24 hours
+monitor.unpause # alias for .pause(0)
+monitor.ok # manually reset to a passing state alias for monitor.ping({state: ok})
+monitor.delete # destroy the monitor
 ```
 
-### Pinging a Monitor
+## Package Configuration
 
-Once you’ve created a monitor, you can continue to use the existing instance of the object to ping the monitor that your task status: `run`, `complete`, or `fail`.
+The package needs to be configured with your account's `API key`, which is available on the [account settings](https://cronitor.io/settings) page. You can also optionally specify an `api_version` and an `environment`. If not provided, your account default is used. These can also be supplied using the environment variables `CRONITOR_API_KEY`, `CRONITOR_API_VERSION`, `CRONITOR_ENVIRONMENT`.
 
 ```ruby
-my_monitor.ping 'run'
-my_monitor.ping 'complete'
-my_monitor.ping 'fail', 'A short description of the failure'
+require 'cronitor'
+
+# your api keys can found here - https://cronitor.io/settings
+Cronitor.api_key = 'apiKey123'
+Cronitor.api_version = '2020-10-01'
+Cronitor.environment = 'cluster_1_prod'
 ```
 
-### Pinging a monitor when you have a Cronitor code
+## Contributing
 
-You may already have the code for a monitor, in which case, the expense of `Cronitor.new` may seem unnecessary (since it makes an HTTP request to check if a monitor exists, and you already know it does).
+Pull requests and features are happily considered! By participating in this project you agree to abide by the [Code of Conduct](http://contributor-covenant.org/version/2/0).
 
-In that case:
+### To contribute
 
-```ruby
-my_monitor = Cronitor.new code: 'abcd'
-```
+Fork, then clone the repo:
 
-The aforementioned ping methods can now be used.
+    git clone git@github.com:your-username/cronitor-ruby.git
 
-## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Set up your machine:
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+    bin/setup
 
-## Contributing
 
-1. Fork it ( https://github.com/evertrue/cronitor/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+Make sure the tests pass:
+
+    rake spec
+
+
+Make your change. You can experiment using:
+
+    bin/console
+
+
+Add tests for your change. Make the tests pass:
+
+    rake spec
+
+Push to your fork and [submit a pull request]( https://github.com/cronitorio/cronitor-ruby/compare/)
+
+
+## Release a new version
+
+The bump gem makes this easy:
+
+1. `rake bump:(major|minor|patch|pre)`
+2. `rake release`

data/Rakefile

@@ -1,7 +1,15 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'bump/tasks'
+require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
+RuboCop::RakeTask.new do |task|
+  task.requires << 'rubocop-rake'
+  task.requires << 'rubocop-rspec'
+end
+
 task default: :spec

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'cronitor'

data/cronitor.gemspec

@@ -1,15 +1,19 @@
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'cronitor/version'
 
 Gem::Specification.new do |spec|
   spec.name        = 'cronitor'
   spec.version     = Cronitor::VERSION
-  spec.authors     = ['Jeff Byrnes']
-  spec.email       = ['thejeffbyrnes@gmail.com']
+  spec.authors     = ['Jeff Byrnes', 'August Flanagan']
+  spec.email       = ['thejeffbyrnes@gmail.com', 'august@cronitor.io']
 
   spec.summary     = 'An interface for the Cronitor API'
-  spec.homepage    = 'https://github.com/evertrue/cronitor'
+  spec.homepage    = 'https://github.com/cronitorio/cronitor-ruby'
+
+  spec.required_ruby_version = '>= 2.5'
 
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
@@ -18,14 +22,16 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'unirest', '~> 1.1'
-  spec.add_dependency 'hashie', '~> 3.4'
+  spec.add_runtime_dependency 'httparty'
 
-  spec.add_development_dependency 'bundler', '~> 1.10'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.3'
-  spec.add_development_dependency 'pry', '~> 0.10'
-  spec.add_development_dependency 'webmock', '~> 1.21'
-  spec.add_development_dependency 'sinatra', '~> 1.4'
   spec.add_development_dependency 'bump', '~> 0.1'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.3'
+  spec.add_development_dependency 'rubocop', '~> 1.8'
+  spec.add_development_dependency 'rubocop-rake', '~> 0.5.1'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.1'
+  spec.add_development_dependency 'sinatra', '~> 2.0'
+  spec.add_development_dependency 'webmock', '~> 3.1'
 end

data/lib/cronitor.rb

@@ -1,110 +1,87 @@
-require 'cronitor/version'
-require 'cronitor/error'
-require 'net/http'
-require 'unirest'
-require 'hashie'
-
-class Cronitor
-  attr_accessor :token, :opts, :code
-  API_URL = 'https://cronitor.io/v1'.freeze
-  PING_URL = 'https://cronitor.link'.freeze
+# frozen_string_literal: true
 
-  def initialize(token: nil, opts: {}, code: nil)
-    @token = token
-    @opts = opts
-    @code = code
+require 'logger'
+require 'json'
+require 'httparty'
+require 'socket'
+require 'time'
+require 'yaml'
 
-    if @token.nil? && @code.nil?
-      raise(
-        Cronitor::Error,
-        'Either a Cronitor API token or an existing monitor code must be ' \
-        'provided'
+require 'cronitor/config'
+require 'cronitor/error'
+require 'cronitor/version'
+require 'cronitor/monitor'
+
+module Cronitor
+  def self.read_config(path = nil, output: false)
+    Cronitor.config = path || Cronitor.config
+    unless Cronitor.config
+      raise ConfigurationError.new(
+        "Must include a path by setting Cronitor.config or passing a path to read_config e.g. \
+        Cronitor.read_config('./cronitor.yaml')"
       )
     end
 
-    if @opts
-      Hashie.symbolize_keys! @opts
-      exists? @opts[:name] if @opts.key? :name
-      human_readable @opts[:rules] if @opts.key? :rules
+    conf = YAML.safe_load(File.read(Cronitor.config))
+    conf.each do |k, _v|
+      raise ConfigurationError.new("Invalid configuration variable: #{k}") unless Cronitor::YAML_KEYS.include?(k)
     end
 
-    create if @code.nil?
-  end
-
-  def create
-    response = Unirest.post(
-      "#{API_URL}/monitors",
-      headers: default_headers.merge('Content-Type' => 'application/json'),
-      auth: { user: token },
-      parameters: opts.to_json
-    )
-
-    @code = response.body['code'] if valid? response
-  end
-
-  def exists?(name)
-    response = Unirest.get(
-      "#{API_URL}/monitors/#{URI.escape(name).gsub('[', '%5B').gsub(']', '%5D')}",
-      headers: default_headers,
-      auth: { user: token }
-    )
-    return false unless response.code == 200
-
-    @code = response.body['code']
+    Cronitor.api_key     = conf[:api_key] if conf[:api_key]
+    Cronitor.api_version = conf[:api_version] if conf[:api_version]
+    Cronitor.environment = conf[:environment] if conf[:environment]
 
-    true
-  end
+    return unless output
 
-  def ping(type, msg = nil)
-    url = "#{PING_URL}/#{code}/#{type}"
-    url += "?msg=#{URI.escape msg}" if %w(run complete fail).include?(type) && !msg.nil?
+    monitors = []
+    Cronitor::MONITOR_TYPES.each do |t|
+      plural_t = "#{t}s"
+      to_parse = conf[t] || conf[plural_t] || nil
+      next unless to_parse
 
-    response = Unirest.get url
-    valid? response
-  end
+      unless to_parse.is_a?(Hash)
+        raise ConfigurationError.new('A Hash with keys corresponding to monitor keys is expected.')
+      end
 
-  def human_readable(rules)
-    rules.each do |rule|
-      unless rule[:human_readable]
-        rule[:human_readable] = "#{rule[:rule_type]} #{rule[:duration]} " \
-                                "#{rule[:time_unit]}"
+      to_parse.each do |key, m|
+        m['key'] = key
+        m['type'] = t
+        monitors << m
       end
     end
+    conf['monitors'] = monitors
+    conf
   end
 
-  private
-
-  def valid?(response)
-    return true if [200, 201].include? response.code
-    server_error? response
-
-    raise Cronitor::Error, error_msg(response.body)
+  def self.apply_config(rollback: false)
+    conf = read_config(output: true)
+    monitors = Monitor.put(monitors: conf.fetch('monitors', []), rollback: rollback)
+    puts("#{monitors.length} monitors #{rollback ? 'validated' : 'synced to Cronitor'}.")
+  rescue ValidationError => e
+    Cronitor.logger.error(e)
   end
 
-  def error_msg(body, msg = [])
-    body.each do |opt, value|
-      if value.respond_to? 'each'
-        value.each do |error_msg|
-          msg << "#{opt}: #{error_msg}"
-        end
-      else
-        msg << "#{opt}: #{value}"
-      end
-    end
-
-    msg.join ' '
+  def self.validate_config
+    apply_config(rollback: true)
   end
 
-  def server_error?(response)
-    return unless [301, 302, 404, 500, 502, 503, 504].include? response.code
-
-    raise(
-      Cronitor::Error,
-      "Something else has gone awry. HTTP status: #{response.code}"
-    )
+  def self.job(key, &block)
+    monitor = Monitor.new(key)
+    series = Time.now.to_f
+    monitor.ping(state: 'run', series: series)
+
+    begin
+      block.call
+      monitor.ping(state: 'complete', series: series)
+    rescue StandardError => e
+      monitor.ping(state: 'fail', message: e.message[[0, e.message.length - 1600].max..-1], series: series)
+      raise e
+    end
   end
 
-  def default_headers
-    { 'Accept' => 'application/json' }
+  def self.monitor_api_url
+    'https://cronitor.io/api/monitors'
   end
 end
+
+Cronitor.read_config(Cronitor.config) unless Cronitor.config.nil?

data/lib/cronitor/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Cronitor
+  TYPE_JOB = 'job'
+  TYPE_HEARTBEAT = 'heartbeat'
+  TYPE_CHECK = 'check'
+  MONITOR_TYPES = [TYPE_JOB, TYPE_HEARTBEAT, TYPE_CHECK].freeze
+  YAML_KEYS = %w[
+    api_key
+    api_version
+    environment
+  ] + MONITOR_TYPES.map { |t| "#{t}s" }
+
+  class << self
+    attr_accessor :api_key, :api_version, :environment, :logger, :config, :_headers
+
+    def configure(&block)
+      block.call(self)
+    end
+  end
+
+  self.api_key = ENV['CRONITOR_API_KEY']
+  self.api_version = ENV['CRONITOR_API_VERSION']
+  self.environment = ENV['CRONITOR_ENVIRONMENT']
+  self.config = ENV['CRONITOR_CONFIG']
+  self.logger = Logger.new($stdout)
+  logger.level = Logger::INFO
+  self._headers = {
+    'Content-Type': 'application/json',
+    'User-Agent': 'cronitor-ruby',
+    'Cronitor-Version': Cronitor.api_version
+  }
+end

data/lib/cronitor/error.rb

@@ -1,4 +1,12 @@
-class Cronitor
+# frozen_string_literal: true
+
+module Cronitor
   class Error < StandardError
   end
+
+  class ValidationError < Error
+  end
+
+  class ConfigurationError < Error
+  end
 end

data/lib/cronitor/monitor.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Cronitor
+  class Monitor
+    attr_reader :key, :api_key, :api_version, :env
+
+    PING_RETRY_THRESHOLD = 5
+
+    def self.put(opts = {})
+      rollback = opts[:rollback] || false
+      opts.delete(:rollback)
+
+      monitors = opts[:monitors] || [opts]
+
+      resp = HTTParty.put(
+        Cronitor.monitor_api_url,
+        basic_auth: {
+          username: Cronitor.api_key,
+          password: ''
+        },
+        body: {
+          monitors: monitors,
+          rollback: rollback
+        }.to_json,
+        headers: Cronitor._headers,
+        timeout: 10
+      )
+
+      case resp.code
+      when 200
+        out = []
+        data = JSON.parse(resp.body)
+
+        (data['monitors'] || []).each do |md|
+          m = Monitor.new(md['key'])
+          m.data = Cronitor.symbolize_keys(md)
+          out << m
+        end
+        out.length == 1 ? out[0] : out
+      when 400
+        raise ValidationError.new(resp.body)
+      else
+        raise Error.new("Error connecting to Cronitor: #{resp.code}")
+      end
+    end
+
+    def self.delete(key)
+      resp = HTTParty.delete(
+        "#{Cronitor.monitor_api_url}/#{key}",
+        timeout: 10,
+        basic_auth: {
+          username: Cronitor.api_key,
+          password: ''
+        },
+        headers: Cronitor._headers
+      )
+      if resp.code != 204
+        Cronitor.logger.error("Error deleting monitor: #{key}")
+        return false
+      end
+      true
+    end
+
+    def initialize(key, api_key: nil, env: nil)
+      @key = key
+      @api_key = api_key || Cronitor.api_key
+      @env = env || Cronitor.environment
+    end
+
+    def data
+      return @data if defined?(@data)
+
+      @data = fetch
+      @data
+    end
+
+    def data=(data)
+      @data = Cronitor.symbolize_keys(data)
+    end
+
+    def ping(params = {})
+      retry_count = params[:retry_count] || 0
+      if api_key.nil?
+        Cronitor.logger.error('No API key detected. Set Cronitor.api_key or initialize Monitor with an api_key:')
+        return false
+      end
+
+      begin
+        ping_url = ping_api_url
+        ping_url = fallback_ping_api_url if retry_count > (PING_RETRY_THRESHOLD / 2)
+
+        response = HTTParty.get(
+          ping_url,
+          query: clean_params(params),
+          timeout: 5,
+          headers: Cronitor._headers,
+          query_string_normalizer: lambda do |query|
+            query.compact!
+            metrics = query[:metric]
+            query.delete(:metric)
+            out = query.map { |k, v| "#{k}=#{v}" }
+            out += metrics.map { |m| "metric=#{m}" } unless metrics.nil?
+            out.join('&')
+          end
+          # query_string_normalizer for metrics. instead of metric[]=foo:1 we want metric=foo:1
+        )
+
+        if response.code != 200
+          Cronitor.logger.error("Cronitor Telemetry Error: #{response.code}")
+          return false
+        end
+        true
+      rescue StandardError => e
+        # rescue instances of StandardError i.e. Timeout::Error, SocketError, etc
+        Cronitor.logger.error("Cronitor Telemetry Error: #{e}")
+        return false if retry_count >= Monitor::PING_RETRY_THRESHOLD
+
+        # apply a backoff before sending the next ping
+        sleep(retry_count * 1.5 * rand)
+        ping(params.merge(retry_count: params[:retry_count] + 1))
+      end
+    end
+
+    def ok
+      ping(state: 'ok')
+    end
+
+    def pause(hours = nil)
+      pause_url = "#{monitor_api_url}/pause"
+      pause_url += "/#{hours}" unless hours.nil?
+
+      resp = HTTParty.get(
+        pause_url,
+        timeout: 5,
+        headers: Cronitor._headers,
+        basic_auth: {
+          username: api_key,
+          password: ''
+        }
+      )
+      puts(resp.code)
+      resp.code == 200
+    end
+
+    def unpause
+      pause(0)
+    end
+
+    def ping_api_url
+      "https://cronitor.link/p/#{api_key}/#{key}"
+    end
+
+    def fallback_ping_api_url
+      "https://cronitor.io/p/#{api_key}/#{key}"
+    end
+
+    def monitor_api_url
+      "#{Cronitor.monitor_api_url}/#{key}"
+    end
+
+    private
+
+    def fetch
+      unless api_key
+        Cronitor.logger.error(
+          'No API key detected. Set Cronitor.api_key or initialize Monitor with the api_key kwarg'
+        )
+        return
+      end
+
+      HTTParty.get(monitor_api_url, timeout: 10, headers: Cronitor._headers, format: :json)
+    end
+
+    def clean_params(params)
+      {
+        state: params.fetch(:state, nil),
+        message: params.fetch(:message, nil),
+        series: params.fetch(:series, nil),
+        host: params.fetch(:host, Socket.gethostname),
+        metric: params[:metrics] ? params[:metrics].map { |k, v| "#{k}:#{v}" } : nil,
+        stamp: Time.now.to_f,
+        env: params.fetch(:env, env)
+      }
+    end
+  end
+
+  def self.symbolize_keys(obj)
+    obj.inject({}) do |memo, (k, v)|
+      memo[k.to_sym] = v
+      memo
+    end
+  end
+end

data/lib/cronitor/version.rb

@@ -1,3 +1,5 @@
-class Cronitor
-  VERSION = '1.1.5'
+# frozen_string_literal: true
+
+module Cronitor
+  VERSION = '4.1.0'
 end

metadata

@@ -1,71 +1,86 @@
 --- !ruby/object:Gem::Specification
 name: cronitor
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 4.1.0
 platform: ruby
 authors:
 - Jeff Byrnes
-autorequire: 
+- August Flanagan
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2017-07-19 00:00:00.000000000 Z
+date: 2021-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: unirest
+  name: httparty
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: hashie
+  name: bump
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
-  type: :runtime
+        version: '0.1'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: bundler
+  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: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -81,72 +96,89 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.3'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '1.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.21'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.21'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: bump
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
-description: 
+        version: '3.1'
+description:
 email:
 - thejeffbyrnes@gmail.com
+- august@cronitor.io
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".editorconfig"
+- ".github/workflows/publish.yml"
+- ".github/workflows/test.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -155,12 +187,14 @@ files:
 - bin/setup
 - cronitor.gemspec
 - lib/cronitor.rb
+- lib/cronitor/config.rb
 - lib/cronitor/error.rb
+- lib/cronitor/monitor.rb
 - lib/cronitor/version.rb
-homepage: https://github.com/evertrue/cronitor
+homepage: https://github.com/cronitorio/cronitor-ruby
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -168,16 +202,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.6
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: An interface for the Cronitor API
 test_files: []

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-rvm:
-  - 2.2
-before_install: gem install bundler -v 1.10