observamax 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 881513afe14041c7127591b00fe015359aa367e53999e74ba50c6ca38ca8c52c
+  data.tar.gz: 37705065491662edfedd75257fa9501a2e4f06950a7d1f46e32980b2ffc8ad24
+SHA512:
+  metadata.gz: 35f4951c5fe07359d62f1f5809e3bc57915d9fc92c6ce1214fefc611ce3098995ff19b950cdf1d6ac9b2fce3f13ac6ecc166e0158bda2f366db453f226f2e673
+  data.tar.gz: ccbd4c99488c31231e7af5d107e61e938a779667e6c3e0f4323b12ac3820d112202531a7ac54841df19ff4d7091c53879ec9b969526d684f9e4917f5e2dbe2c9

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ObservaMax
+
+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,155 @@
+# ObservaMax Ruby SDK
+
+Official Ruby SDK for the ObservaMax API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'observamax'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself:
+
+```bash
+gem install observamax
+```
+
+## Quick Start
+
+```ruby
+require 'observamax'
+
+# Create client
+client = Observamax::Client.new(api_key: "om_live_your_api_key")
+
+# List all monitors
+monitors = client.monitors.list
+monitors.each do |monitor|
+  puts "#{monitor.name}: #{monitor.last_status}"
+end
+```
+
+## Usage Examples
+
+### Monitors
+
+```ruby
+# List monitors with pagination
+monitors = client.monitors.list(page: 1, limit: 50)
+
+# Get a specific monitor
+monitor = client.monitors.get("monitor-id")
+
+# Create a new monitor
+monitor = client.monitors.create(
+  url: "https://api.example.com/health",
+  name: "My API",
+  check_interval: 5
+)
+
+# Update a monitor
+monitor = client.monitors.update("monitor-id", name: "Updated Name")
+
+# Pause/Resume a monitor
+client.monitors.pause("monitor-id")
+client.monitors.resume("monitor-id")
+
+# Delete a monitor
+client.monitors.delete("monitor-id")
+```
+
+### Alerts
+
+```ruby
+# List all alerts
+alerts = client.alerts.list
+
+# Get a specific alert
+alert = client.alerts.get("alert-id")
+
+# Acknowledge an alert
+alert = client.alerts.acknowledge("alert-id")
+
+# Resolve an alert
+alert = client.alerts.resolve("alert-id")
+```
+
+### Uptime Statistics
+
+```ruby
+# Get uptime stats for all monitors
+stats = client.uptime.get_stats(period: "7d") # 24h, 7d, or 30d
+
+# Get uptime stats for a specific monitor
+stats = client.uptime.get_monitor_stats("monitor-id", period: "30d")
+
+puts "Uptime: #{stats.uptime}%"
+puts "Avg Response: #{stats.avg_response_ms}ms"
+```
+
+## Configuration
+
+### Custom Base URL
+
+```ruby
+client = Observamax::Client.new(
+  api_key: "api_key",
+  base_url: "https://custom.observamax.com/api/v1"
+)
+```
+
+### Custom Timeout
+
+```ruby
+client = Observamax::Client.new(
+  api_key: "api_key",
+  timeout: 60
+)
+```
+
+## Error Handling
+
+```ruby
+begin
+  monitor = client.monitors.get("invalid-id")
+rescue Observamax::NotFoundError
+  puts "Monitor not found"
+rescue Observamax::AuthenticationError
+  puts "Invalid API key"
+rescue Observamax::RateLimitError => e
+  puts "Rate limited, retry after #{e.retry_after} seconds"
+rescue Observamax::ValidationError => e
+  puts "Validation error: #{e.details}"
+rescue Observamax::APIError => e
+  puts "API error (#{e.status_code}): #{e.message}"
+end
+```
+
+## Pagination
+
+```ruby
+# Iterate through all pages
+page = 1
+loop do
+  monitors = client.monitors.list(page: page, limit: 50)
+  break if monitors.data.empty?
+
+  monitors.each do |monitor|
+    puts monitor.name
+  end
+
+  page += 1
+end
+```
+
+## License
+
+MIT

data/lib/observamax/client.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Observamax
+  # HTTP client for the ObservaMax API
+  class Client
+    DEFAULT_BASE_URL = "https://observamax.com/api/v1"
+    DEFAULT_TIMEOUT = 30
+
+    attr_reader :monitors, :alerts, :uptime
+
+    def initialize(api_key:, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT)
+      raise ArgumentError, "API key is required" if api_key.nil? || api_key.empty?
+
+      @api_key = api_key
+      @base_url = base_url.chomp("/")
+      @timeout = timeout
+
+      @monitors = MonitorsAPI.new(self)
+      @alerts = AlertsAPI.new(self)
+      @uptime = UptimeAPI.new(self)
+    end
+
+    def request(method:, path:, params: nil, body: nil)
+      uri = build_uri(path, params)
+      request = build_request(method, uri, body)
+
+      response = execute_request(uri, request)
+      handle_response(response)
+    end
+
+    private
+
+    def build_uri(path, params)
+      uri = URI.parse("#{@base_url}#{path}")
+      if params && !params.empty?
+        uri.query = URI.encode_www_form(params.compact)
+      end
+      uri
+    end
+
+    def build_request(method, uri, body)
+      request_class = case method.to_s.upcase
+                      when "GET" then Net::HTTP::Get
+                      when "POST" then Net::HTTP::Post
+                      when "PATCH" then Net::HTTP::Patch
+                      when "DELETE" then Net::HTTP::Delete
+                      else raise ArgumentError, "Unsupported HTTP method: #{method}"
+                      end
+
+      request = request_class.new(uri)
+      request["Authorization"] = "Bearer #{@api_key}"
+      request["Content-Type"] = "application/json"
+      request["Accept"] = "application/json"
+      request.body = body.to_json if body
+
+      request
+    end
+
+    def execute_request(uri, request)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.read_timeout = @timeout
+      http.open_timeout = @timeout
+      http.request(request)
+    end
+
+    def handle_response(response)
+      body = response.body ? JSON.parse(response.body) : nil
+
+      case response.code.to_i
+      when 200..299
+        body
+      when 401
+        raise AuthenticationError, body&.dig("error") || "Invalid or expired API key"
+      when 403
+        raise PermissionError, body&.dig("error") || "Permission denied"
+      when 404
+        raise NotFoundError, body&.dig("error") || "Resource not found"
+      when 429
+        retry_after = response["Retry-After"]&.to_i
+        raise RateLimitError.new(body&.dig("error") || "Rate limit exceeded", retry_after: retry_after)
+      when 400
+        raise ValidationError.new(body&.dig("error") || "Validation error", details: body&.dig("details"))
+      else
+        raise APIError.new(body&.dig("error") || "Request failed", status_code: response.code.to_i)
+      end
+    end
+  end
+
+  # Monitors API
+  class MonitorsAPI
+    def initialize(client)
+      @client = client
+    end
+
+    def list(page: nil, limit: nil)
+      response = @client.request(
+        method: :get,
+        path: "/monitors",
+        params: { page: page, limit: limit }
+      )
+      PaginatedResponse.new(data: response["data"], meta: response["meta"], model_class: Monitor)
+    end
+
+    def get(id)
+      response = @client.request(method: :get, path: "/monitors/#{id}")
+      Monitor.new(response)
+    end
+
+    def create(url:, **options)
+      body = { url: url }.merge(options)
+      response = @client.request(method: :post, path: "/monitors", body: body)
+      Monitor.new(response)
+    end
+
+    def update(id, **options)
+      response = @client.request(method: :patch, path: "/monitors/#{id}", body: options)
+      Monitor.new(response)
+    end
+
+    def delete(id)
+      @client.request(method: :delete, path: "/monitors/#{id}")
+      nil
+    end
+
+    def pause(id)
+      update(id, is_enabled: false)
+    end
+
+    def resume(id)
+      update(id, is_enabled: true)
+    end
+  end
+
+  # Alerts API
+  class AlertsAPI
+    def initialize(client)
+      @client = client
+    end
+
+    def list(page: nil, limit: nil)
+      response = @client.request(
+        method: :get,
+        path: "/alerts",
+        params: { page: page, limit: limit }
+      )
+      PaginatedResponse.new(data: response["data"], meta: response["meta"], model_class: Alert)
+    end
+
+    def get(id)
+      response = @client.request(method: :get, path: "/alerts/#{id}")
+      Alert.new(response)
+    end
+
+    def acknowledge(id)
+      response = @client.request(method: :post, path: "/alerts/#{id}/acknowledge")
+      Alert.new(response)
+    end
+
+    def resolve(id)
+      response = @client.request(method: :post, path: "/alerts/#{id}/resolve")
+      Alert.new(response)
+    end
+  end
+
+  # Uptime API
+  class UptimeAPI
+    def initialize(client)
+      @client = client
+    end
+
+    def get_stats(period: "24h")
+      response = @client.request(
+        method: :get,
+        path: "/uptime",
+        params: { period: period }
+      )
+      response.map { |item| UptimeStats.new(item) }
+    end
+
+    def get_monitor_stats(monitor_id, period: "24h")
+      response = @client.request(
+        method: :get,
+        path: "/monitors/#{monitor_id}/uptime",
+        params: { period: period }
+      )
+      UptimeStats.new(response)
+    end
+  end
+end

data/lib/observamax/errors.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Observamax
+  # Base error class for all ObservaMax errors
+  class Error < StandardError; end
+
+  # Raised when authentication fails
+  class AuthenticationError < Error
+    def initialize(message = "Invalid or expired API key")
+      super
+    end
+  end
+
+  # Raised when the user lacks permission
+  class PermissionError < Error
+    def initialize(message = "Permission denied")
+      super
+    end
+  end
+
+  # Raised when a resource is not found
+  class NotFoundError < Error
+    def initialize(message = "Resource not found")
+      super
+    end
+  end
+
+  # Raised when rate limit is exceeded
+  class RateLimitError < Error
+    attr_reader :retry_after
+
+    def initialize(message = "Rate limit exceeded", retry_after: nil)
+      @retry_after = retry_after
+      super(message)
+    end
+  end
+
+  # Raised when request validation fails
+  class ValidationError < Error
+    attr_reader :details
+
+    def initialize(message = "Validation error", details: nil)
+      @details = details
+      super(message)
+    end
+  end
+
+  # Generic API error
+  class APIError < Error
+    attr_reader :status_code
+
+    def initialize(message, status_code: nil)
+      @status_code = status_code
+      super(message)
+    end
+  end
+end

data/lib/observamax/models.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Observamax
+  # Monitor status constants
+  module MonitorStatus
+    UP = "up"
+    DOWN = "down"
+    DEGRADED = "degraded"
+    PENDING = "pending"
+  end
+
+  # Monitor type constants
+  module MonitorType
+    HTTP = "http"
+    TCP = "tcp"
+    DNS = "dns"
+    PING = "ping"
+    HEARTBEAT = "heartbeat"
+  end
+
+  # Alert type constants
+  module AlertType
+    DOWN = "down"
+    UP = "up"
+    DEGRADED = "degraded"
+    CHANGE = "change"
+  end
+
+  # Alert severity constants
+  module AlertSeverity
+    INFO = "info"
+    WARNING = "warning"
+    CRITICAL = "critical"
+  end
+
+  # Base model class with attribute access
+  class Model
+    def initialize(attributes = {})
+      @attributes = {}
+      attributes.each do |key, value|
+        @attributes[key.to_s] = value
+      end
+    end
+
+    def [](key)
+      @attributes[key.to_s]
+    end
+
+    def to_h
+      @attributes.dup
+    end
+
+    def method_missing(method_name, *args)
+      key = method_name.to_s
+      if @attributes.key?(key)
+        @attributes[key]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @attributes.key?(method_name.to_s) || super
+    end
+  end
+
+  # Represents a monitor
+  class Monitor < Model; end
+
+  # Represents an alert
+  class Alert < Model; end
+
+  # Represents uptime statistics
+  class UptimeStats < Model; end
+
+  # Represents a paginated response
+  class PaginatedResponse
+    attr_reader :data, :meta
+
+    def initialize(data:, meta:, model_class:)
+      @data = data.map { |item| model_class.new(item) }
+      @meta = meta
+    end
+
+    def total
+      meta["total"]
+    end
+
+    def page
+      meta["page"]
+    end
+
+    def limit
+      meta["limit"]
+    end
+
+    def each(&block)
+      @data.each(&block)
+    end
+
+    include Enumerable
+  end
+end

data/lib/observamax/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Observamax
+  VERSION = "1.0.0"
+end

data/lib/observamax.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "observamax/version"
+require_relative "observamax/errors"
+require_relative "observamax/models"
+require_relative "observamax/client"
+
+# ObservaMax SDK for Ruby
+#
+# @example Basic usage
+#   client = Observamax::Client.new(api_key: "om_live_...")
+#   monitors = client.monitors.list
+#   monitors.each do |monitor|
+#     puts "#{monitor.name}: #{monitor.last_status}"
+#   end
+#
+module Observamax
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: observamax
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- ObservaMax
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Ruby client library for the ObservaMax website monitoring API. Monitor
+  uptime, track alerts, and manage your monitors programmatically.
+email:
+- support@observamax.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/observamax.rb
+- lib/observamax/client.rb
+- lib/observamax/errors.rb
+- lib/observamax/models.rb
+- lib/observamax/version.rb
+homepage: https://observamax.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://observamax.com
+  source_code_uri: https://github.com/observamax/sdk-ruby
+  documentation_uri: https://observamax.com/developers
+  changelog_uri: https://github.com/observamax/sdk-ruby/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Official Ruby SDK for ObservaMax API
+test_files: []