docker-swarm 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97102c26aff73c5426373e1cfbfb542fd2cf4e82404a3b1de4833b8e82d5d66a
-  data.tar.gz: 3a9288b1dc9eae6d4849503de616561c94af264ec467e9450c2a4e2863e4706f
+  metadata.gz: b43832405fbf723559703102c4d84a42c27c677d601625de43c81ceb2db804d0
+  data.tar.gz: 57d9349d4ce67bc9e157c6d235e5cf4925b0af05df53ce0f29fffd2bd888fbb7
 SHA512:
-  metadata.gz: fb9eea1d60221c643681e50ea18a4a9830967e46ef226543c62df85c26102c9fd60b26a6f77f35f12c6e5ff86ca15ec280175ca656c266587e7737414837f91c
-  data.tar.gz: 0b223dd63b9c69a14a24c07b3be527876d9535c1114f53a507152fd2d28cbf126a387b0b72ddbba18290aa621c49369adaf83f2e80ca68f3d2dad8def9c749bf
+  metadata.gz: 72c9fa985935caac2386f9b782ac3728f4c5ffbd121db6f5b36a6e1291eafed9bc5500bd0841385caad69ad5430152b5d11d10261c4ad73fbda86bd9cc7053b3
+  data.tar.gz: e841eaa3cad32138f809a40556a2c798fb97e7c92bf40975d2076adbd6650a699eb5635880f6c50d598de2c1017045d61771ff88f7a794f8482a71bdb32b7fe3

data/lib/docker-swarm.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "docker_swarm"

data/lib/docker_swarm/base.rb

@@ -13,8 +13,19 @@ module DockerSwarm
         Api::ENDPOINTS[resource_name.to_sym]
       end
 
+      # Key in the JSON response that contains the array of items.
+      # Override in subclasses if the API returns a wrapped object (e.g., Volumes).
+      # @return [String, nil]
+      def root_key
+        nil
+      end
+
       def all(filters = {})
-        _fetch_all(filters).map { |data| new(data) }
+        response = _fetch_all(filters)
+        return [] if response.blank?
+
+        data = root_key && response.is_a?(Hash) ? response[root_key] : response
+        Array(data).map { |item| new(item) }
       end
 
       def find(id)

data/lib/docker_swarm/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module DockerSwarm
+  class Configuration
+    attr_accessor :socket_path, :logger, :log_level
+
+    def initialize
+      @socket_path = "unix:///var/run/docker.sock"
+      @logger = Logger.new($stdout)
+      @log_level = Logger::INFO
+    end
+  end
+end

data/lib/docker_swarm/connection.rb

@@ -10,29 +10,110 @@ module DockerSwarm
     end
 
     def request(options = {})
-      normalized_path = socket_path.sub(/^unix:\/\//, "")
-      client(normalized_path).request(options).body
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      
+      log_event("request_started", 
+                level: :debug,
+                data: { method: options[:method], path: options[:path] })
+
+      response = client.request(options)
+      
+      log_event("request_success", 
+                data: { 
+                  method: options[:method], 
+                  path: options[:path], 
+                  status: response.status, 
+                  duration_ms: calculate_duration(start_time) 
+                })
+      
+      response.body
     rescue => e
-      if e.is_a?(Excon::Error::Socket)
-        raise Errors::Communication, "Docker socket error: #{e.message}"
+      # Excon suele envolver excepciones de middleware en Excon::Error::Socket.
+      # Intentamos recuperar la causa original si es una de nuestras excepciones.
+      actual_error = (e.respond_to?(:cause) && e.cause&.class&.name&.include?("DockerSwarm::Error")) ? e.cause : e
+      
+      log_event("request_failure", 
+                level: :error,
+                data: { 
+                  method: options[:method], 
+                  path: options[:path], 
+                  error: actual_error.class.name,
+                  message: actual_error.message,
+                  duration_ms: calculate_duration(start_time) 
+                })
+                
+      if actual_error.class.name.include?("DockerSwarm::Error")
+        raise actual_error
+      elsif actual_error.is_a?(Excon::Error::Socket)
+        raise ::DockerSwarm::Error::Communication, "Docker socket error: #{actual_error.message}"
       else
-        raise e
+        raise actual_error
       end
     end
+
     private
 
-    def client(path)
-      @client ||= Excon.new(
-        "unix:///",
-        socket: path,
-        middlewares: [
-          Excon::Middleware::ResponseParser,
-          Excon::Middleware::RedirectFollower,
-          Middleware::RequestEncoder,
-          Middleware::ResponseJSONParser,
-          Middleware::ErrorHandler
-        ]
-      )
+    def log_event(event, level: :info, data: {})
+      return unless logger
+      # Respetar el nivel de log antes de procesar nada
+      return if level == :debug && logger.level > Logger::DEBUG
+
+      log_block = proc do
+        begin
+          payload = {
+            component: "docker_swarm.connection",
+            event: event,
+            source: "http"
+          }.merge(data)
+
+          payload.map do |k, v|
+            val = k.to_s =~ /password|token|api_key|auth|secret/i ? "[FILTERED]" : v
+            "#{k}=#{val}"
+          end.join(" ")
+        rescue
+          "component=docker_swarm.connection event=logging_error"
+        end
+      end
+
+      if level == :debug
+        logger.debug(&log_block)
+      else
+        logger.send(level, log_block.call)
+      end
+    end
+
+    def calculate_duration(start_time)
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+    end
+
+    def common_middlewares
+      # Usamos los middlewares por defecto de Excon para garantizar que todas las llaves internas
+      # (como :retries_remaining o :instrumentor_name) se inicialicen correctamente.
+      Excon.defaults[:middlewares] + [
+        Excon::Middleware::RedirectFollower,
+        Middleware::RequestEncoder,
+        Middleware::ResponseJSONParser,
+        Middleware::ErrorHandler
+      ]
+    end
+
+    def client
+      debug_enabled = logger&.level == Logger::DEBUG
+      
+      options = { 
+        middlewares: common_middlewares, 
+        logger: logger,
+        debug_request: debug_enabled,
+        debug_response: debug_enabled,
+        # Si debug_enabled es true, Excon usará su lógica interna de debug con el logger proporcionado
+        retry_limit: 0
+      }
+
+      @client ||= if socket_path.start_with?("unix://")
+                    Excon.new("unix:///", options.merge(socket: socket_path.sub(/^unix:\/\//, "")))
+                  else
+                    Excon.new(socket_path, options)
+                  end
     end
   end
 end

data/lib/docker_swarm/errors.rb

@@ -3,7 +3,7 @@
 module DockerSwarm
   class Error < StandardError; end
 
-  module Errors
+  class Error
     class BadRequest < Error; end
     class Unauthorized < Error; end
     class Forbidden < Error; end
@@ -19,4 +19,31 @@ module DockerSwarm
     class TooManyRequests < Error; end
     class Communication < Error; end
   end
+
+  # Aliases para permitir acceso directo DockerSwarm::Conflict
+  BadRequest          = Error::BadRequest
+  Unauthorized        = Error::Unauthorized
+  Forbidden           = Error::Forbidden
+  NotFound            = Error::NotFound
+  NotAcceptable       = Error::NotAcceptable
+  RequestTimeout      = Error::RequestTimeout
+  Conflict            = Error::Conflict
+  UnprocessableEntity = Error::UnprocessableEntity
+  InternalServerError = Error::InternalServerError
+  BadGateway          = Error::BadGateway
+  ServiceUnavailable  = Error::ServiceUnavailable
+  GatewayTimeout      = Error::GatewayTimeout
+  TooManyRequests     = Error::TooManyRequests
+  Communication       = Error::Communication
+
+  # Módulo Errors para compatibilidad adicional
+  module Errors
+    def self.const_missing(name)
+      if ::DockerSwarm::Error.const_defined?(name)
+        ::DockerSwarm::Error.const_get(name)
+      else
+        super
+      end
+    end
+  end
 end

data/lib/docker_swarm/middleware/error_handler.rb

@@ -9,31 +9,58 @@ module DockerSwarm
         status = env[:response][:status]
         body = env[:response][:body]
 
+        return @stack.response_call(env) if (200..299).include?(status)
+
+        error_msg = error_message(body)
+        log_business_error(env, status, error_msg)
+
         case status
-        when 200..299
-          # Continuar normalmente
-        when 400 then raise Errors::BadRequest, error_message(body)
-        when 401 then raise Errors::Unauthorized, error_message(body)
-        when 403 then raise Errors::Forbidden, error_message(body)
-        when 404 then raise Errors::NotFound, error_message(body)
-        when 406 then raise Errors::NotAcceptable, error_message(body)
-        when 408 then raise Errors::RequestTimeout, error_message(body)
-        when 409 then raise Errors::Conflict, error_message(body)
-        when 422 then raise Errors::UnprocessableEntity, body
-        when 429 then raise Errors::TooManyRequests, error_message(body)
-        when 500 then raise Errors::InternalServerError, error_message(body)
-        when 502 then raise Errors::BadGateway, error_message(body)
-        when 503 then raise Errors::ServiceUnavailable, error_message(body)
-        when 504 then raise Errors::GatewayTimeout, error_message(body)
+        when 400 then raise ::DockerSwarm::BadRequest, error_msg
+        when 401 then raise ::DockerSwarm::Unauthorized, error_msg
+        when 403 then raise ::DockerSwarm::Forbidden, error_msg
+        when 404 then raise ::DockerSwarm::NotFound, error_msg
+        when 406 then raise ::DockerSwarm::NotAcceptable, error_msg
+        when 408 then raise ::DockerSwarm::RequestTimeout, error_msg
+        when 409 then raise ::DockerSwarm::Conflict, error_msg
+        when 422 then raise ::DockerSwarm::UnprocessableEntity, body
+        when 429 then raise ::DockerSwarm::TooManyRequests, error_msg
+        when 500 then raise ::DockerSwarm::InternalServerError, error_msg
+        when 502 then raise ::DockerSwarm::BadGateway, error_msg
+        when 503 then raise ::DockerSwarm::ServiceUnavailable, error_msg
+        when 504 then raise ::DockerSwarm::GatewayTimeout, error_msg
         else
-          raise Errors::Error, "HTTP #{status}: #{error_message(body)}"
+          raise ::DockerSwarm::Error, "HTTP #{status}: #{error_msg}"
         end
-
-        @stack.response_call(env)
       end
 
       private
 
+      def log_business_error(env, status, message)
+        logger = env[:logger]
+        return unless logger
+
+        begin
+          payload = {
+            component: "docker_swarm.middleware.error_handler",
+            event: "business_error",
+            source: "http",
+            status: status,
+            message: message,
+            method: env[:method],
+            path: env[:path]
+          }
+
+          kv_string = payload.map do |k, v|
+            val = k.to_s =~ /password|token|api_key|auth|secret/i ? "[FILTERED]" : v
+            "#{k}=#{val}"
+          end.join(" ")
+
+          logger.error(kv_string)
+        rescue
+          # Resilience: logging should not crash the app
+        end
+      end
+
       def error_message(body)
         if body.is_a?(Hash)
           body["message"] || body["error"] || body.to_json

data/lib/docker_swarm/models/volume.rb

@@ -5,12 +5,8 @@ module DockerSwarm
     include Concerns::Creatable
     include Concerns::Deletable
 
-    def self.all(filters = {})
-      response = _fetch_all(filters)
-      return [] if response.blank?
-      
-      data = response.is_a?(Hash) ? response["Volumes"] : response
-      Array(data).map { |item| new(item) }
+    def self.root_key
+      "Volumes"
     end
   end
 end

data/lib/docker_swarm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DockerSwarm
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/docker_swarm.rb

@@ -7,6 +7,34 @@ require "excon"
 require "json"
 require "logger"
 
+module DockerSwarm
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      @configuration ||= Configuration.new
+      yield(@configuration) if block_given?
+      
+      if @configuration.logger.respond_to?(:level=)
+        @configuration.logger.level = @configuration.log_level
+      end
+      
+      @connection = nil
+    end
+
+    def connection
+      configure unless @configuration
+      @connection ||= Connection.new(@configuration.socket_path, @configuration.logger)
+    end
+
+    def request(options = {})
+      connection.request(options)
+    end
+  end
+end
+
+# Primero cargamos la configuración porque la clase DockerSwarm la usa arriba
+require_relative "docker_swarm/configuration"
 require_relative "docker_swarm/version"
 require_relative "docker_swarm/errors"
 require_relative "docker_swarm/middleware/request_encoder"
@@ -31,32 +59,3 @@ require_relative "docker_swarm/models/network"
 require_relative "docker_swarm/models/config"
 require_relative "docker_swarm/models/secret"
 require_relative "docker_swarm/models/volume"
-
-module DockerSwarm
-  class << self
-    attr_accessor :configuration
-
-    def configure
-      self.configuration ||= Configuration.new
-      yield(configuration) if block_given?
-    end
-
-    def connection
-      configure unless configuration
-      @connection ||= Connection.new(configuration.socket_path, configuration.logger)
-    end
-
-    def request(options = {})
-      connection.request(options)
-    end
-  end
-
-  class Configuration
-    attr_accessor :socket_path, :logger
-
-    def initialize
-      @socket_path = "unix:///var/run/docker.sock"
-      @logger = defined?(Rails) ? Rails.logger : Logger.new($stdout)
-    end
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: docker-swarm
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Gabriel
@@ -89,12 +89,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- lib/docker-swarm.rb
 - lib/docker_swarm.rb
 - lib/docker_swarm/api.rb
 - lib/docker_swarm/base.rb
 - lib/docker_swarm/concerns/creatable.rb
 - lib/docker_swarm/concerns/deletable.rb
 - lib/docker_swarm/concerns/updatable.rb
+- lib/docker_swarm/configuration.rb
 - lib/docker_swarm/connection.rb
 - lib/docker_swarm/errors.rb
 - lib/docker_swarm/middleware/error_handler.rb