hooksniff 1.1.1 → 1.3.0

data/lib/hooksniff/api/rate_limit.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class RateLimit
+    def initialize(client)
+      @client = client
+    end
+
+    def list
+      @client.execute_request("GET", "/v1/rate-limits")
+    end
+
+    def get(endpoint_id)
+      @client.execute_request("GET", "/v1/rate-limits/#{endpoint_id}")
+    end
+
+    def set(endpoint_id, attrs)
+      @client.execute_request("POST", "/v1/rate-limits/#{endpoint_id}", body: attrs)
+    end
+
+    def delete(endpoint_id)
+      @client.execute_request("DELETE", "/v1/rate-limits/#{endpoint_id}")
+      nil
+    end
+  end
+end

data/lib/hooksniff/api/routing.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class Routing
+    def initialize(client)
+      @client = client
+    end
+
+    def get(endpoint_id)
+      @client.execute_request("GET", "/v1/routing/#{endpoint_id}/routing")
+    end
+
+    def update(endpoint_id, attrs)
+      @client.execute_request("PUT", "/v1/routing/#{endpoint_id}/routing", body: attrs)
+    end
+
+    def get_health(endpoint_id)
+      @client.execute_request("GET", "/v1/routing/#{endpoint_id}/health")
+    end
+  end
+end

data/lib/hooksniff/api/schema.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class Schema
+    def initialize(client)
+      @client = client
+    end
+
+    def list
+      @client.execute_request("GET", "/v1/schemas")
+    end
+
+    def get(id)
+      @client.execute_request("GET", "/v1/schemas/#{id}")
+    end
+
+    def register(attrs)
+      @client.execute_request("POST", "/v1/schemas", body: attrs)
+    end
+
+    def validate(id, attrs)
+      @client.execute_request("POST", "/v1/schemas/#{id}/validate", body: attrs)
+    end
+  end
+end

data/lib/hooksniff/api/search.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class Search
+    def initialize(client)
+      @client = client
+    end
+
+    def search(params = {})
+      @client.execute_request("GET", "/v1/search", query_params: params)
+    end
+  end
+end

data/lib/hooksniff/api/service_token.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class ServiceToken
+    def initialize(client)
+      @client = client
+    end
+
+    def list
+      @client.execute_request("GET", "/v1/service-tokens")
+    end
+
+    def create(attrs)
+      @client.execute_request("POST", "/v1/service-tokens", body: attrs)
+    end
+
+    def delete(id)
+      @client.execute_request("DELETE", "/v1/service-tokens/#{id}")
+      nil
+    end
+  end
+end

data/lib/hooksniff/api/sso.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class Sso
+    def initialize(client)
+      @client = client
+    end
+
+    def get_config
+      @client.execute_request("GET", "/v1/sso/config")
+    end
+
+    def upsert_config(attrs)
+      @client.execute_request("POST", "/v1/sso/config", body: attrs)
+    end
+
+    def delete_config
+      @client.execute_request("DELETE", "/v1/sso/config")
+      nil
+    end
+
+    def test
+      @client.execute_request("POST", "/v1/sso/test")
+    end
+  end
+end

data/lib/hooksniff/api/statistics.rb

@@ -20,18 +20,5 @@ module HookSniff
       )
       AggregateEventTypesOut.deserialize(res)
     end
-
-    def app_stats(app_id, options = {})
-      options = options.transform_keys(&:to_s)
-      res = @client.execute_request(
-        "GET",
-        "/v1/stats/app/#{app_id}",
-        query_params: {
-          "since" => options["since"],
-          "until" => options["until"]
-        }
-      )
-      res
-    end
   end
 end

data/lib/hooksniff/api/stream.rb

@@ -7,39 +7,58 @@ module HookSniff
     end
 
     def list_channels
-      @client.request(:get, "/api/v1/stream/channels")
+      @client.request(:get, "/v1/stream/channels")
     end
 
     def get_channel(id)
-      @client.request(:get, "/api/v1/stream/channels/#{id}")
+      @client.request(:get, "/v1/stream/channels/#{id}")
     end
 
     def create_channel(attrs)
-      @client.request(:post, "/api/v1/stream/channels", attrs)
+      @client.request(:post, "/v1/stream/channels", attrs)
     end
 
     def update_channel(id, attrs)
-      @client.request(:put, "/api/v1/stream/channels/#{id}", attrs)
+      @client.request(:put, "/v1/stream/channels/#{id}", attrs)
     end
 
     def delete_channel(id)
-      @client.request(:delete, "/api/v1/stream/channels/#{id}")
+      @client.request(:delete, "/v1/stream/channels/#{id}")
     end
 
     def list_messages(id, params = {})
-      @client.request(:get, "/api/v1/stream/channels/#{id}/messages", params)
+      @client.request(:get, "/v1/stream/channels/#{id}/messages", params)
     end
 
     def list_subscriptions
-      @client.request(:get, "/api/v1/stream/subscriptions")
+      @client.request(:get, "/v1/stream/subscriptions")
     end
 
     def disconnect_subscription(id)
-      @client.request(:delete, "/api/v1/stream/subscriptions/#{id}")
+      @client.request(:delete, "/v1/stream/subscriptions/#{id}")
     end
 
     def publish(body)
-      @client.request(:post, "/api/v1/stream/publish", body)
+      @client.request(:post, "/v1/stream/publish", body)
     end
   end
 end
+
+    # Subscribe to real-time events via SSE
+    # @param channel_id [String] Channel ID to subscribe to
+    # @param block [Block] Callback for each event
+    # @return [void]
+    def subscribe(channel_id, &block)
+      @client.request_stream(:get, "/v1/stream/channels/#{channel_id}/subscribe") do |event|
+        block.call(event)
+      end
+    end
+
+    # Subscribe to delivery events (legacy SSE endpoint)
+    # @param block [Block] Callback for each event
+    # @return [void]
+    def subscribe_deliveries(&block)
+      @client.request_stream(:get, "/v1/stream/deliveries") do |event|
+        block.call(event)
+      end
+    end

data/lib/hooksniff/api/team.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class Team
+    def initialize(client)
+      @client = client
+    end
+
+    def list
+      @client.execute_request("GET", "/v1/teams")
+    end
+
+    def get(id)
+      @client.execute_request("GET", "/v1/teams/#{id}")
+    end
+
+    def create(attrs)
+      @client.execute_request("POST", "/v1/teams", body: attrs)
+    end
+
+    def accept_invite(attrs)
+      @client.execute_request("POST", "/v1/teams/accept-invite", body: attrs)
+    end
+
+    def invite(team_id, attrs)
+      @client.execute_request("POST", "/v1/teams/#{team_id}/invite", body: attrs)
+    end
+
+    def list_members(team_id)
+      @client.execute_request("GET", "/v1/teams/#{team_id}/members")
+    end
+
+    def remove_member(team_id, user_id)
+      @client.execute_request("DELETE", "/v1/teams/#{team_id}/members/#{user_id}")
+      nil
+    end
+
+    def change_role(team_id, user_id, attrs)
+      @client.execute_request("PUT", "/v1/teams/#{team_id}/members/#{user_id}/role", body: attrs)
+    end
+  end
+end

data/lib/hooksniff/api/template.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class Template
+    def initialize(client)
+      @client = client
+    end
+
+    def list
+      @client.execute_request("GET", "/v1/templates")
+    end
+
+    def get(id)
+      @client.execute_request("GET", "/v1/templates/#{id}")
+    end
+
+    def apply(id, attrs)
+      @client.execute_request("POST", "/v1/templates/#{id}/apply", body: attrs)
+    end
+  end
+end

data/lib/hooksniff/errors.rb

@@ -41,6 +41,13 @@ module HookSniff
     end
   end
 
+  # 408 Request Timeout
+  class RequestTimeoutError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 408, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
   # 409 Conflict
   class ConflictError < ApiError
     def initialize(response_headers: {}, response_body: nil)
@@ -48,6 +55,20 @@ module HookSniff
     end
   end
 
+  # 410 Gone
+  class GoneError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 410, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 413 Payload Too Large
+  class PayloadTooLargeError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 413, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
   # 422 Unprocessable Entity
   class UnprocessableEntityError < ApiError
     attr_reader :validation_errors
@@ -75,6 +96,13 @@ module HookSniff
     end
   end
 
+  # 501 Not Implemented
+  class NotImplementedError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 501, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
   # 502 Bad Gateway
   class BadGatewayError < ApiError
     def initialize(response_headers: {}, response_body: nil)
@@ -96,6 +124,45 @@ module HookSniff
     end
   end
 
+  # 507 Insufficient Storage
+  class InsufficientStorageError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 507, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 508 Loop Detected
+  class LoopDetectedError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 508, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # Timeout — request exceeded the configured timeout
+  class TimeoutError < StandardError
+    attr_reader :code
+    def initialize(message = "Request timeout")
+      @code = 0
+      super(message)
+    end
+  end
+
+  # Network error — connection failed
+  class NetworkError < StandardError
+    attr_reader :code
+    def initialize(message = "Network error")
+      @code = 0
+      super(message)
+    end
+  end
+
+  # Authentication error — token invalid, expired, or missing
+  class AuthenticationError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 401, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
   # Create the appropriate error from a status code
   def self.create_error_from_status(status_code, response_headers: {}, response_body: nil)
     case status_code
@@ -107,8 +174,14 @@ module HookSniff
       ForbiddenError.new(response_headers: response_headers, response_body: response_body)
     when 404
       NotFoundError.new(response_headers: response_headers, response_body: response_body)
+    when 408
+      RequestTimeoutError.new(response_headers: response_headers, response_body: response_body)
     when 409
       ConflictError.new(response_headers: response_headers, response_body: response_body)
+    when 410
+      GoneError.new(response_headers: response_headers, response_body: response_body)
+    when 413
+      PayloadTooLargeError.new(response_headers: response_headers, response_body: response_body)
     when 422
       UnprocessableEntityError.new(response_headers: response_headers, response_body: response_body)
     when 429
@@ -116,12 +189,18 @@ module HookSniff
       RateLimitError.new(retry_after: retry_after, response_headers: response_headers, response_body: response_body)
     when 500
       InternalServerError.new(response_headers: response_headers, response_body: response_body)
+    when 501
+      NotImplementedError.new(response_headers: response_headers, response_body: response_body)
     when 502
       BadGatewayError.new(response_headers: response_headers, response_body: response_body)
     when 503
       ServiceUnavailableError.new(response_headers: response_headers, response_body: response_body)
     when 504
       GatewayTimeoutError.new(response_headers: response_headers, response_body: response_body)
+    when 507
+      InsufficientStorageError.new(response_headers: response_headers, response_body: response_body)
+    when 508
+      LoopDetectedError.new(response_headers: response_headers, response_body: response_body)
     else
       ApiError.new(code: status_code, response_headers: response_headers, response_body: response_body)
     end

data/lib/hooksniff/hooksniff_http_client.rb

@@ -47,7 +47,9 @@ module HookSniff
       # Create request object
       request = request_class.new(uri.request_uri)
       request["Authorization"] = "Bearer #{@token}"
-      request["User-Agent"] = "hooksniff-libs/#{VERSION}/ruby"
+      sdk_ua = "hooksniff-libs/#{VERSION}/ruby"
+      request["User-Agent"] = sdk_ua
+      request["X-HookSniff-SDK"] = sdk_ua
       request["hooksniff-req-id"] = rand(0...(2 ** 64))
 
       # Add headers
@@ -83,26 +85,41 @@ module HookSniff
     end
 
     private def execute_request_with_retries(request, http)
-      res = http.request(request)
+      res = nil
+      retries = [1, 2, 4] # seconds: 1s, 2s, 4s exponential backoff
+      max_retries = retries.length
+
+      retries.each_with_index do |sleep_duration, index|
+        begin
+          res = http.request(request)
+        rescue Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout, Timeout::Error, Errno::ETIMEDOUT, IOError => _e
+          # Timeout — retry
+          if index < max_retries - 1
+            sleep(sleep_duration)
+            request["hooksniff-retry-count"] = index + 1
+            next
+          else
+            raise
+          end
+        end
 
-      [0.05, 0.1, 0.2].each_with_index do |sleep_duration, index|
         # 429 Rate Limit — respect Retry-After header
         if Integer(res.code) == 429
           retry_after = res["Retry-After"]
           delay = retry_after ? retry_after.to_f : sleep_duration
           sleep(delay)
           request["hooksniff-retry-count"] = index + 1
-          res = http.request(request)
           next
         end
 
-        unless Integer(res.code) >= 500
-          break
+        # 5xx Server Error — exponential backoff
+        if Integer(res.code) >= 500 && index < max_retries - 1
+          sleep(sleep_duration)
+          request["hooksniff-retry-count"] = index + 1
+          next
         end
 
-        sleep(sleep_duration)
-        request["hooksniff-retry-count"] = index + 1
-        res = http.request(request)
+        break
       end
 
       res
@@ -126,3 +143,25 @@ module HookSniff
     end
   end
 end
+
+# Response metadata accessor
+module HookSniff
+  class << self
+    attr_accessor :last_response
+  end
+end
+
+# Debug logging helper
+module HookSniff
+  module DebugLogger
+    def self.log_request(method, url)
+      return unless HookSniff.respond_to?(:debug) && HookSniff.debug
+      puts "[HookSniff] → #{method.upcase} #{url}"
+    end
+
+    def self.log_response(status_code, elapsed_ms)
+      return unless HookSniff.respond_to?(:debug) && HookSniff.debug
+      puts "[HookSniff] ← #{status_code} (#{elapsed_ms}ms)"
+    end
+  end
+end

data/lib/hooksniff/models/aggregate_event_types_out.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  class AggregateEventTypesOut
+    # The QueueBackgroundTask's ID.
+    attr_accessor :id
+    attr_accessor :status
+    attr_accessor :task
+    attr_accessor :updated_at
+
+    ALL_FIELD ||= ["id", "status", "task", "updated_at"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `HookSniff::AggregateEventTypesOut` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of HookSniff::AggregateEventTypesOut")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["id"] = attributes["id"]
+      attrs["status"] = HookSniff::BackgroundTaskStatus.deserialize(attributes["status"])
+      attrs["task"] = HookSniff::BackgroundTaskType.deserialize(attributes["task"])
+      attrs["updated_at"] = DateTime.rfc3339(attributes["updatedAt"]).to_time
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["id"] = HookSniff::serialize_primitive(@id) if @id
+      out["status"] = HookSniff::serialize_schema_ref(@status) if @status
+      out["task"] = HookSniff::serialize_schema_ref(@task) if @task
+      out["updatedAt"] = HookSniff::serialize_primitive(@updated_at) if @updated_at
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/hooksniff/models/message_attempt_recovered_event.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  # Sent on a successful dispatch after an earlier failure op webhook has already been sent.
+  class MessageAttemptRecoveredEvent
+    attr_accessor :data
+    attr_accessor :type
+
+    ALL_FIELD ||= ["data", "type"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `HookSniff::MessageAttemptRecoveredEvent` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of HookSniff::MessageAttemptRecoveredEvent")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["data"] = HookSniff::MessageAttemptRecoveredEventData.deserialize(attributes["data"])
+      attrs["type"] = attributes["type"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["data"] = HookSniff::serialize_schema_ref(@data) if @data
+      out["type"] = HookSniff::serialize_primitive(@type) if @type
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/hooksniff/models/message_attempt_recovered_event_data.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  # Sent when a message delivery has failed (all of the retry attempts have been exhausted) as a "message.attempt.exhausted" type or after it's failed four times as a "message.attempt.failing" event.
+  class MessageAttemptRecoveredEventData
+    # The Application's ID.
+    attr_accessor :app_id
+    # The Application's UID.
+    attr_accessor :app_uid
+    # The Endpoint's ID.
+    attr_accessor :endpoint_id
+    attr_accessor :last_attempt
+    # The Message's UID.
+    attr_accessor :msg_event_id
+    # The Message's ID.
+    attr_accessor :msg_id
+
+    ALL_FIELD ||= ["app_id", "app_uid", "endpoint_id", "last_attempt", "msg_event_id", "msg_id"].freeze
+    private_constant :ALL_FIELD
+
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `HookSniff::MessageAttemptRecoveredEventData` new method"
+        )
+      end
+
+      attributes.each do |k, v|
+        unless ALL_FIELD.include?(k.to_s)
+          fail(ArgumentError, "The field #{k} is not part of HookSniff::MessageAttemptRecoveredEventData")
+        end
+
+        instance_variable_set("@#{k}", v)
+        instance_variable_set("@__#{k}_is_defined", true)
+      end
+    end
+
+    def self.deserialize(attributes = {})
+      attributes = attributes.transform_keys(&:to_s)
+      attrs = Hash.new
+      attrs["app_id"] = attributes["appId"]
+      attrs["app_uid"] = attributes["appUid"]
+      attrs["endpoint_id"] = attributes["endpointId"]
+      attrs["last_attempt"] = HookSniff::MessageAttemptFailedData.deserialize(attributes["lastAttempt"])
+      attrs["msg_event_id"] = attributes["msgEventId"]
+      attrs["msg_id"] = attributes["msgId"]
+      new(attrs)
+    end
+
+    def serialize
+      out = Hash.new
+      out["appId"] = HookSniff::serialize_primitive(@app_id) if @app_id
+      out["appUid"] = HookSniff::serialize_primitive(@app_uid) if @app_uid
+      out["endpointId"] = HookSniff::serialize_primitive(@endpoint_id) if @endpoint_id
+      out["lastAttempt"] = HookSniff::serialize_schema_ref(@last_attempt) if @last_attempt
+      out["msgEventId"] = HookSniff::serialize_primitive(@msg_event_id) if @msg_event_id
+      out["msgId"] = HookSniff::serialize_primitive(@msg_id) if @msg_id
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end