hooksniff 0.1.0 → 1.0.0

data/lib/hooksniff/api/statistics.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module HookSniff
+  class Statistics
+    def initialize(client)
+      @client = client
+    end
+
+    def aggregate_event_types(options = {})
+      options = options.transform_keys(&:to_s)
+      res = @client.execute_request(
+        "GET",
+        "/v1/stats/event-types",
+        query_params: {
+          "since" => options["since"],
+          "until" => options["until"]
+        }
+      )
+      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_error.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class ApiError < StandardError
+    attr_reader :code, :response_headers, :response_body
+
+    # Usage examples:
+    #   ApiError.new
+    #   ApiError.new("message")
+    #   ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
+    #   ApiError.new(:code => 404, :message => "Not Found")
+    def initialize(arg = nil)
+      if arg.is_a?(Hash)
+        if arg.key?(:message) || arg.key?("message")
+          super(arg[:message] || arg["message"])
+        else
+          super(arg)
+        end
+
+        arg.each do |k, v|
+          instance_variable_set("@#{k}", v)
+        end
+      else
+        super(arg)
+        @message = arg
+      end
+    end
+
+    # Override to_s to display a friendly error message
+    def to_s
+      message
+    end
+
+    def message
+      if @message.nil?
+        msg = "Error message: the server returns an error"
+      else
+        msg = @message
+      end
+
+      msg += "\nHTTP status code: #{code}" if code
+      msg += "\nResponse headers: #{response_headers}" if response_headers
+      msg += "\nResponse body: #{response_body}" if response_body
+
+      msg
+    end
+  end
+end

data/lib/hooksniff/errors.rb

@@ -1,43 +1,129 @@
 # frozen_string_literal: true
 
 module HookSniff
-  class Error < StandardError
-    attr_reader :status_code, :error_code
+  # Base error class for all HookSniff API errors
+  class ApiError < StandardError
+    attr_reader :code, :response_headers, :response_body
 
-    def initialize(message, status_code: nil, error_code: nil)
-      super(message)
-      @status_code = status_code
-      @error_code = error_code
+    def initialize(code:, response_headers: {}, response_body: nil)
+      @code = code
+      @response_headers = response_headers
+      @response_body = response_body
+      super("HookSniff API error #{code}")
     end
   end
 
-  class AuthenticationError < Error
-    def initialize(message = "Unauthorized: invalid or missing API key")
-      super(message, status_code: 401, error_code: "UNAUTHORIZED")
+  # 400 Bad Request
+  class BadRequestError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 400, response_headers: response_headers, response_body: response_body)
     end
   end
 
-  class NotFoundError < Error
-    def initialize(message = "Resource not found")
-      super(message, status_code: 404, error_code: "NOT_FOUND")
+  # 401 Unauthorized
+  class UnauthorizedError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 401, response_headers: response_headers, response_body: response_body)
     end
   end
 
-  class RateLimitError < Error
-    def initialize(message = "Rate limit exceeded")
-      super(message, status_code: 429, error_code: "RATE_LIMIT_EXCEEDED")
+  # 403 Forbidden
+  class ForbiddenError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 403, response_headers: response_headers, response_body: response_body)
     end
   end
 
-  class ValidationError < Error
-    def initialize(message = "Bad request")
-      super(message, status_code: 400, error_code: "BAD_REQUEST")
+  # 404 Not Found
+  class NotFoundError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 404, response_headers: response_headers, response_body: response_body)
     end
   end
 
-  class PayloadTooLargeError < Error
-    def initialize(message = "Payload too large")
-      super(message, status_code: 413, error_code: "PAYLOAD_TOO_LARGE")
+  # 409 Conflict
+  class ConflictError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 409, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 422 Unprocessable Entity
+  class UnprocessableEntityError < ApiError
+    attr_reader :validation_errors
+
+    def initialize(validation_errors: [], response_headers: {}, response_body: nil)
+      super(code: 422, response_headers: response_headers, response_body: response_body)
+      @validation_errors = validation_errors
+    end
+  end
+
+  # 429 Rate Limited
+  class RateLimitError < ApiError
+    attr_reader :retry_after
+
+    def initialize(retry_after: nil, response_headers: {}, response_body: nil)
+      super(code: 429, response_headers: response_headers, response_body: response_body)
+      @retry_after = retry_after
+    end
+  end
+
+  # 500 Internal Server Error
+  class InternalServerError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 500, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 502 Bad Gateway
+  class BadGatewayError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 502, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 503 Service Unavailable
+  class ServiceUnavailableError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 503, response_headers: response_headers, response_body: response_body)
+    end
+  end
+
+  # 504 Gateway Timeout
+  class GatewayTimeoutError < ApiError
+    def initialize(response_headers: {}, response_body: nil)
+      super(code: 504, 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
+    when 400
+      BadRequestError.new(response_headers: response_headers, response_body: response_body)
+    when 401
+      UnauthorizedError.new(response_headers: response_headers, response_body: response_body)
+    when 403
+      ForbiddenError.new(response_headers: response_headers, response_body: response_body)
+    when 404
+      NotFoundError.new(response_headers: response_headers, response_body: response_body)
+    when 409
+      ConflictError.new(response_headers: response_headers, response_body: response_body)
+    when 422
+      UnprocessableEntityError.new(response_headers: response_headers, response_body: response_body)
+    when 429
+      retry_after = response_headers["retry-after"]&.to_i
+      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 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)
+    else
+      ApiError.new(code: status_code, response_headers: response_headers, response_body: response_body)
     end
   end
 end

data/lib/hooksniff/hooksniff.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class HookSniffOptions
+    attr_accessor :debug
+    attr_accessor :server_url
+
+    def initialize(debug = false, server_url = nil)
+      @debug = debug
+      @server_url = server_url
+    end
+  end
+
+  class Client
+    attr_accessor :authentication
+    attr_accessor :endpoint
+    attr_accessor :event_type
+    attr_accessor :health
+    attr_accessor :message
+    attr_accessor :message_attempt
+    attr_accessor :statistics
+
+    def initialize(auth_token, options = HookSniffOptions.new)
+      uri = URI(options.server_url || "https://hooksniff-api-1046140057667.europe-west1.run.app")
+      api_client = HookSniffHttpClient.new(auth_token, uri)
+
+      @authentication = Authentication.new(api_client)
+      @endpoint = Endpoint.new(api_client)
+      @event_type = EventType.new(api_client)
+      @health = Health.new(api_client)
+      @message = Message.new(api_client)
+      @message_attempt = MessageAttempt.new(api_client)
+      @statistics = Statistics.new(api_client)
+    end
+  end
+end

data/lib/hooksniff/hooksniff_http_client.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+require "cgi"
+require "uri"
+require "net/http"
+require "securerandom"
+
+
+module HookSniff
+  class HookSniffHttpClient
+    def initialize(token, base_url)
+      @token = token
+      @base_url = base_url
+    end
+
+    def execute_request(method, path, **kwargs)
+      query_params = kwargs[:query_params] || {}
+      headers = kwargs[:headers] || {}
+      body = kwargs[:body] || {}
+
+      uri = URI("#{@base_url}#{path}")
+      encoded_query = encode_query_params(query_params)
+      if encoded_query != ""
+        uri.query = encoded_query
+      end
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+
+      # Dynamically select the request class based on method
+      request_class = case method.to_s.upcase
+      when "GET"
+        Net::HTTP::Get
+      when "POST"
+        Net::HTTP::Post
+      when "PUT"
+        Net::HTTP::Put
+      when "DELETE"
+        Net::HTTP::Delete
+      when "PATCH"
+        Net::HTTP::Patch
+      when "HEAD"
+        Net::HTTP::Head
+      else
+        raise ArgumentError, "Unsupported HTTP method: #{method}"
+      end
+
+      # Create request object
+      request = request_class.new(uri.request_uri)
+      request["Authorization"] = "Bearer #{@token}"
+      request["User-Agent"] = "hooksniff-libs/#{VERSION}/ruby"
+      request["hooksniff-req-id"] = rand(0...(2 ** 64))
+
+      # Add headers
+      headers.each { |key, value| request[key] = value }
+
+      # Check if idempotency-key header already exists
+      if !request.key?("idempotency-key") && method.to_s.upcase == "POST"
+        request["idempotency-key"] = "auto_" + SecureRandom.uuid.to_s
+      end
+
+      # Add body for non-GET requests
+      if %w[POST PUT PATCH].include?(method.to_s.upcase) && !body.nil?
+        request.body = body.to_json
+        request["Content-Type"] = "application/json"
+      end
+
+      res = execute_request_with_retries(request, http)
+
+      # Execute request
+      if Integer(res.code) == 204
+        nil
+      elsif Integer(res.code) >= 200 && Integer(res.code) <= 299
+        JSON.parse(res.body)
+      else
+        fail(
+          ApiError.new(
+            :code => Integer(res.code),
+            :response_headers => res.each_header.to_h,
+            :response_body => res.body
+          )
+        )
+      end
+    end
+
+    private def execute_request_with_retries(request, http)
+      res = http.request(request)
+
+      [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
+        end
+
+        sleep(sleep_duration)
+        request["hooksniff-retry-count"] = index + 1
+        res = http.request(request)
+      end
+
+      res
+    end
+
+    private def encode_query_params(query_params = {})
+      encoded_query_pairs = []
+      query_params.each do |k, v|
+        unless v.nil?
+          if v.kind_of?(Array)
+            encoded_query_pairs.append("#{k}=" + CGI::escape(v.sort.join(",")))
+          elsif v.kind_of?(Time)
+            encoded_query_pairs.append("#{k}=#{CGI::escape(v.utc.to_datetime.rfc3339)}")
+          else
+            encoded_query_pairs.append("#{k}=#{CGI::escape(v)}")
+          end
+        end
+      end
+
+      encoded_query_pairs.join("&")
+    end
+  end
+end

data/lib/hooksniff/http_error_out.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class HttpErrorOut
+    attr_accessor :code
+
+    attr_accessor :detail
+
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail(ArgumentError, "The input argument (attributes) must be a hash in `HookSniff::HttpErrorOut` initialize method")
+      end
+
+      @detail = attributes[:"detail"]
+      @code = attributes[:"code"]
+    end
+  end
+end

data/lib/hooksniff/http_validation_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HookSniff
+  class HTTPValidationError
+    attr_accessor :detail
+
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail(
+          ArgumentError,
+          "The input argument (attributes) must be a hash in `HookSniff::HTTPValidationError` initialize method"
+        )
+      end
+
+      @detail = attributes[:"detail"]
+    end
+  end
+end

data/lib/hooksniff/internal.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module HookSniff
+  private_constant :HttpErrorOut
+  private_constant :HTTPValidationError
+  private_constant :ValidationError
+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/endpoint_created_event.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  # Sent when an endpoint is created.
+  class EndpointCreatedEvent
+    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::EndpointCreatedEvent` 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::EndpointCreatedEvent")
+        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::EndpointCreatedEventData.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/endpoint_created_event_data.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  # Sent when an endpoint is created, updated, or deleted
+  class EndpointCreatedEventData
+    # The Application's ID.
+    attr_accessor :app_id
+    # The Application's UID.
+    attr_accessor :app_uid
+    # The Endpoint's ID.
+    attr_accessor :endpoint_id
+    # The Endpoint's UID.
+    attr_accessor :endpoint_uid
+
+    ALL_FIELD ||= ["app_id", "app_uid", "endpoint_id", "endpoint_uid"].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::EndpointCreatedEventData` 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::EndpointCreatedEventData")
+        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["endpoint_uid"] = attributes["endpointUid"]
+      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["endpointUid"] = HookSniff::serialize_primitive(@endpoint_uid) if @endpoint_uid
+      out
+    end
+
+    # Serializes the object to a json string
+    # @return String
+    def to_json
+      JSON.dump(serialize)
+    end
+  end
+end

data/lib/hooksniff/models/endpoint_deleted_event.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# This file is @generated
+require "json"
+
+module HookSniff
+  # Sent when an endpoint is deleted.
+  class EndpointDeletedEvent
+    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::EndpointDeletedEvent` 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::EndpointDeletedEvent")
+        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::EndpointDeletedEventData.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