mistral_translator 0.1.0 → 0.2.1

data/lib/mistral_translator/client.rb

@@ -4,144 +4,147 @@ require "net/http"
 require "json"
 require "uri"
 require_relative "logger"
+require_relative "client_helpers"
+require_relative "security"
 
 module MistralTranslator
   class Client
-    def initialize(api_key: nil)
+    include ClientHelpers::RequestHandler
+    include ClientHelpers::ErrorHandler
+    include ClientHelpers::BatchHandler
+    include ClientHelpers::LoggingHelper
+
+    def initialize(api_key: nil, rate_limiter: nil)
       @api_key = api_key || MistralTranslator.configuration.api_key!
       @base_uri = MistralTranslator.configuration.api_url
       @model = MistralTranslator.configuration.model
       @retry_delays = MistralTranslator.configuration.retry_delays
+      @rate_limiter = rate_limiter || Security::BasicRateLimiter.new
     end
 
-    def complete(prompt, max_tokens: nil, temperature: nil)
-      response = make_request_with_retry(prompt, max_tokens, temperature)
-      parsed_response = JSON.parse(response.body)
+    def complete(prompt, max_tokens: nil, temperature: nil, context: {})
+      # Vérifier le rate limit avant de faire la requête
+      @rate_limiter.wait_and_record!
 
-      content = parsed_response.dig("choices", 0, "message", "content")
-      raise InvalidResponseError, "No content in API response" if content.nil? || content.empty?
+      ctx = (context || {}).merge(operation: :complete)
+      start_time = Time.now
+      trigger_translation_start_callback(ctx, prompt)
+
+      response = make_request_with_retry(prompt, max_tokens, temperature, ctx)
+      content = extract_content_from_response(response)
 
+      trigger_translation_complete_callback(ctx, prompt, content, start_time)
       content
     rescue JSON::ParserError => e
-      raise InvalidResponseError, "Invalid JSON in API response: #{e.message}"
+      handle_json_parse_error(e, ctx)
     rescue NoMethodError => e
-      raise InvalidResponseError, "Invalid response structure: #{e.message}"
+      handle_response_structure_error(e, ctx)
     end
 
-    def chat(prompt, max_tokens: nil, temperature: nil)
-      response = make_request_with_retry(prompt, max_tokens, temperature)
-      parsed_response = JSON.parse(response.body)
+    def chat(prompt, max_tokens: nil, temperature: nil, context: {})
+      # Vérifier le rate limit avant de faire la requête
+      @rate_limiter.wait_and_record!
 
-      parsed_response.dig("choices", 0, "message", "content")
+      ctx = (context || {}).merge(operation: :chat)
+      start_time = Time.now
+      trigger_translation_start_callback(ctx, prompt)
+
+      response = make_request_with_retry(prompt, max_tokens, temperature, ctx)
+      content = extract_chat_content_from_response(response)
+
+      trigger_translation_complete_callback(ctx, prompt, content, start_time)
+      content
     rescue JSON::ParserError => e
-      raise InvalidResponseError, "JSON parse error: #{e.message}"
+      handle_json_parse_error(e, ctx)
     rescue NoMethodError => e
-      raise InvalidResponseError, "Invalid response structure: #{e.message}"
+      handle_response_structure_error(e, ctx)
     end
 
-    private
-
-    def make_request_with_retry(prompt, max_tokens, temperature, attempt = 0)
-      response = make_request(prompt, max_tokens, temperature)
-
-      # Vérifier les erreurs dans la réponse
-      check_response_for_errors(response)
-
-      if rate_limit_exceeded?(response)
-        handle_rate_limit(prompt, max_tokens, temperature, attempt)
-      else
-        response
+    # Nouvelle méthode pour traduction par batch optimisée
+    def translate_batch(requests, batch_size: 5)
+      start_time = Time.now
+      results = []
+      success_count = 0
+      error_count = 0
+
+      requests.each_slice(batch_size) do |batch|
+        batch_results = process_batch_slice(batch)
+        results.concat(batch_results[:results])
+        success_count += batch_results[:success_count]
+        error_count += batch_results[:error_count]
+
+        # Délai entre les batches pour éviter les rate limits
+        sleep(2) unless batch == requests.last(batch_size)
       end
-    end
-
-    def make_request(prompt, max_tokens, temperature)
-      uri = URI("#{@base_uri}/v1/chat/completions")
-
-      request_body = build_request_body(prompt, max_tokens, temperature)
 
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = (uri.scheme == "https")
-      http.read_timeout = 60 # 60 secondes de timeout
+      total_duration = Time.now - start_time
+      MistralTranslator.configuration.trigger_batch_complete(
+        requests.size,
+        total_duration,
+        success_count,
+        error_count
+      )
 
-      request = Net::HTTP::Post.new(uri.path, headers)
-      request.body = request_body.to_json
-
-      response = http.request(request)
-      log_request_response(request_body, response)
-
-      response
-    rescue Net::ReadTimeout, Timeout::Error => e
-      raise ApiError, "Request timeout: #{e.message}"
-    rescue Net::HTTPError => e
-      raise ApiError, "HTTP error: #{e.message}"
+      results
     end
 
-    def build_request_body(prompt, max_tokens, temperature)
-      body = {
-        model: @model,
-        messages: [{ role: "user", content: prompt }]
-      }
-
-      body[:max_tokens] = max_tokens if max_tokens
-      body[:temperature] = temperature if temperature
+    private
 
-      body
+    def trigger_translation_start_callback(context, prompt)
+      MistralTranslator.configuration.trigger_translation_start(
+        context[:from_locale],
+        context[:to_locale],
+        prompt&.length || 0
+      )
     end
 
-    def headers
-      {
-        "Authorization" => "Bearer #{@api_key}",
-        "Content-Type" => "application/json",
-        "User-Agent" => "mistral-translator-gem/#{MistralTranslator::VERSION}"
-      }
-    end
+    def extract_content_from_response(response)
+      parsed_response = JSON.parse(response.body)
+      content = parsed_response.dig("choices", 0, "message", "content")
+      raise InvalidResponseError, "No content in API response" if content.nil? || content.empty?
 
-    def check_response_for_errors(response)
-      case response.code.to_i
-      when 401
-        raise AuthenticationError, "Invalid API key"
-      when 429
-        # Rate limit sera géré séparément
-        nil
-      when 400..499
-        raise ApiError, "Client error (#{response.code})}"
-      when 500..599
-        raise ApiError, "Server error (#{response.code})}"
-      end
+      content
     end
 
-    def rate_limit_exceeded?(response)
-      return true if response.code.to_i == 429
-
-      return false unless response.code.to_i == 200
-
-      body_content = response.body.to_s
-      return false if body_content.length > 1000
-
-      body_content.match?(/rate.?limit|quota.?exceeded/i)
+    def extract_chat_content_from_response(response)
+      parsed_response = JSON.parse(response.body)
+      parsed_response.dig("choices", 0, "message", "content")
     end
 
-    def handle_rate_limit(prompt, max_tokens, temperature, attempt)
-      unless attempt < @retry_delays.length
-        raise RateLimitError, "API rate limit exceeded after #{@retry_delays.length} retries"
-      end
-
-      wait_time = @retry_delays[attempt]
-      log_rate_limit_retry(wait_time, attempt)
-      sleep(wait_time)
-      make_request_with_retry(prompt, max_tokens, temperature, attempt + 1)
+    def trigger_translation_complete_callback(context, prompt, content, start_time)
+      duration = Time.now - start_time
+      MistralTranslator.configuration.trigger_translation_complete(
+        context[:from_locale],
+        context[:to_locale],
+        prompt&.length || 0,
+        content&.length || 0,
+        duration
+      )
     end
 
-    def log_request_response(_request_body, response)
-      # Log seulement si mode verbose activé
-      Logger.debug_if_verbose("Request sent to API", sensitive: true)
-      Logger.debug_if_verbose("Response received: #{response.code}", sensitive: false)
+    def handle_json_parse_error(error, context)
+      MistralTranslator.configuration.trigger_translation_error(
+        context[:from_locale],
+        context[:to_locale],
+        error,
+        context[:attempt] || 0
+      )
+      message = if context[:operation] == :chat
+                  "JSON parse error: #{error.message}"
+                else
+                  "Invalid JSON in API response: #{error.message}"
+                end
+      raise InvalidResponseError, message
     end
 
-    def log_rate_limit_retry(wait_time, attempt)
-      message = "Rate limit exceeded, retrying in #{wait_time} seconds (attempt #{attempt + 1})"
-      # Log une seule fois par session pour éviter le spam
-      Logger.warn_once(message, key: "rate_limit_retry", sensitive: false, ttl: 60)
+    def handle_response_structure_error(error, context)
+      MistralTranslator.configuration.trigger_translation_error(
+        context[:from_locale],
+        context[:to_locale],
+        error,
+        context[:attempt] || 0
+      )
+      raise InvalidResponseError, "Invalid response structure: #{error.message}"
     end
   end
 end

data/lib/mistral_translator/client_helpers.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module MistralTranslator
+  module ClientHelpers
+    # Helper pour la gestion des requêtes HTTP
+    module RequestHandler
+      def make_request(prompt, max_tokens, temperature)
+        uri = URI("#{@base_uri}/v1/chat/completions")
+
+        request_body = build_request_body(prompt, max_tokens, temperature)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.read_timeout = 60 # 60 secondes de timeout
+
+        request = Net::HTTP::Post.new(uri.path, headers)
+        request.body = request_body.to_json
+
+        response = http.request(request)
+        log_request_response(request_body, response)
+
+        response
+      rescue Net::ReadTimeout, Timeout::Error => e
+        raise ApiError, "Request timeout: #{e.message}"
+      rescue Net::HTTPError => e
+        raise ApiError, "HTTP error: #{e.message}"
+      end
+
+      def build_request_body(prompt, max_tokens, temperature)
+        body = {
+          model: @model,
+          messages: [{ role: "user", content: prompt }]
+        }
+
+        body[:max_tokens] = max_tokens if max_tokens
+        body[:temperature] = temperature if temperature
+
+        body
+      end
+
+      def headers
+        {
+          "Authorization" => "Bearer #{@api_key}",
+          "Content-Type" => "application/json",
+          "User-Agent" => "mistral-translator-gem/#{MistralTranslator::VERSION}"
+        }
+      end
+    end
+
+    # Helper pour la gestion des erreurs et retry
+    module ErrorHandler
+      def make_request_with_retry(prompt, max_tokens, temperature, context, attempt = 0)
+        context[:attempt] = attempt
+        response = make_request(prompt, max_tokens, temperature)
+
+        # Vérifier les erreurs dans la réponse
+        check_response_for_errors(response)
+
+        if rate_limit_exceeded?(response)
+          handle_rate_limit(prompt, max_tokens, temperature, context, attempt)
+        else
+          response
+        end
+      end
+
+      def check_response_for_errors(response)
+        case response.code.to_i
+        when 401
+          raise AuthenticationError, "Invalid API key"
+        when 429
+          # Rate limit sera géré séparément
+          nil
+        when 400..499
+          raise ApiError, "Client error (#{response.code})}"
+        when 500..599
+          raise ApiError, "Server error (#{response.code})}"
+        end
+      end
+
+      def rate_limit_exceeded?(response)
+        return true if response.code.to_i == 429
+
+        return false unless response.code.to_i == 200
+
+        body_content = response.body.to_s
+        return false if body_content.length > 1000
+
+        body_content.match?(/rate.?limit|quota.?exceeded/i)
+      end
+
+      def handle_rate_limit(prompt, max_tokens, temperature, context, attempt)
+        unless attempt < @retry_delays.length
+          raise RateLimitError, "API rate limit exceeded after #{@retry_delays.length} retries"
+        end
+
+        wait_time = @retry_delays[attempt]
+
+        # Trigger callback pour rate limit
+        MistralTranslator.configuration.trigger_rate_limit(
+          context[:from_locale],
+          context[:to_locale],
+          wait_time,
+          attempt + 1
+        )
+
+        log_rate_limit_retry(wait_time, attempt)
+        sleep(wait_time)
+        make_request_with_retry(prompt, max_tokens, temperature, context, attempt + 1)
+      end
+    end
+
+    # Helper pour la gestion des batches
+    module BatchHandler
+      def process_batch_slice(batch)
+        results = []
+        success_count = 0
+        error_count = 0
+
+        batch.each do |request|
+          context = {
+            from_locale: request[:from],
+            to_locale: request[:to],
+            attempt: 0
+          }
+
+          result = complete(request[:prompt], context: context)
+          results << {
+            success: true,
+            result: result,
+            original_request: request
+          }
+          success_count += 1
+        rescue StandardError => e
+          results << {
+            success: false,
+            error: e.message,
+            original_request: request
+          }
+          error_count += 1
+        end
+
+        { results: results, success_count: success_count, error_count: error_count }
+      end
+    end
+
+    # Helper pour le logging
+    module LoggingHelper
+      def log_request_response(request_body, response)
+        # Log seulement si mode verbose activé
+        Logger.debug_if_verbose("Request sent to API: #{request_body.to_json}", sensitive: true)
+        Logger.debug_if_verbose("Response received: #{response.code}", sensitive: false)
+      end
+
+      def log_rate_limit_retry(wait_time, attempt)
+        message = "Rate limit exceeded, retrying in #{wait_time} seconds (attempt #{attempt + 1})"
+        # Log une seule fois par session pour éviter le spam
+        Logger.warn_once(message, key: "rate_limit_retry", sensitive: false, ttl: 60)
+      end
+    end
+  end
+end

data/lib/mistral_translator/configuration.rb

@@ -2,7 +2,10 @@
 
 module MistralTranslator
   class Configuration
-    attr_accessor :api_key, :api_url, :model, :default_max_tokens, :default_temperature, :retry_delays
+    attr_accessor :api_key, :model, :default_max_tokens, :default_temperature, :retry_delays,
+                  :on_translation_start, :on_translation_complete, :on_translation_error,
+                  :on_rate_limit, :on_batch_complete, :enable_metrics
+    attr_reader :api_url
 
     def initialize
       @api_key = nil
@@ -11,6 +14,24 @@ module MistralTranslator
       @default_max_tokens = nil
       @default_temperature = nil
       @retry_delays = [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+
+      # Callbacks pour le monitoring et la customisation
+      @on_translation_start = nil
+      @on_translation_complete = nil
+      @on_translation_error = nil
+      @on_rate_limit = nil
+      @on_batch_complete = nil
+      @enable_metrics = false
+
+      # Métriques intégrées
+      @metrics = {
+        total_translations: 0,
+        total_characters: 0,
+        total_duration: 0.0,
+        rate_limits_hit: 0,
+        errors_count: 0,
+        translations_by_language: Hash.new(0)
+      }
     end
 
     def api_key!
@@ -21,6 +42,146 @@ module MistralTranslator
 
       @api_key
     end
+
+    def api_url=(url)
+      validate_api_url(url)
+      @api_url = url
+    end
+
+    # Méthodes pour les callbacks
+    def trigger_translation_start(from_locale, to_locale, text_length)
+      @on_translation_start&.call(from_locale, to_locale, text_length, Time.now)
+
+      return unless @enable_metrics
+
+      @metrics[:total_translations] += 1
+      @metrics[:total_characters] += text_length
+      @metrics[:translations_by_language]["#{from_locale}->#{to_locale}"] += 1
+    end
+
+    def trigger_translation_complete(from_locale, to_locale, original_length, translated_length, duration)
+      @on_translation_complete&.call(from_locale, to_locale, original_length, translated_length, duration)
+
+      return unless @enable_metrics
+
+      @metrics[:total_duration] += duration
+    end
+
+    def trigger_translation_error(from_locale, to_locale, error, attempt)
+      @on_translation_error&.call(from_locale, to_locale, error, attempt, Time.now)
+
+      return unless @enable_metrics
+
+      @metrics[:errors_count] += 1
+    end
+
+    def trigger_rate_limit(from_locale, to_locale, wait_time, attempt)
+      @on_rate_limit&.call(from_locale, to_locale, wait_time, attempt, Time.now)
+
+      return unless @enable_metrics
+
+      @metrics[:rate_limits_hit] += 1
+    end
+
+    def trigger_batch_complete(batch_size, total_duration, success_count, error_count)
+      @on_batch_complete&.call(batch_size, total_duration, success_count, error_count)
+    end
+
+    # Métriques
+    def metrics
+      return {} unless @enable_metrics
+
+      @metrics.merge({
+                       average_translation_time: if @metrics[:total_translations].positive?
+                                                   (@metrics[:total_duration] / @metrics[:total_translations]).round(3)
+                                                 else
+                                                   0
+                                                 end,
+                       average_characters_per_translation: if @metrics[:total_translations].positive?
+                                                             (@metrics[:total_characters] /
+                                                               @metrics[:total_translations]).round(0)
+                                                           else
+                                                             0
+                                                           end,
+                       error_rate: if @metrics[:total_translations].positive?
+                                     ((@metrics[:errors_count].to_f / @metrics[:total_translations]) * 100).round(2)
+                                   else
+                                     0
+                                   end
+                     })
+    end
+
+    def reset_metrics!
+      @metrics = {
+        total_translations: 0,
+        total_characters: 0,
+        total_duration: 0.0,
+        rate_limits_hit: 0,
+        errors_count: 0,
+        translations_by_language: Hash.new(0)
+      }
+    end
+
+    # Configuration helpers pour les callbacks les plus communs
+    def setup_rails_logging
+      return unless defined?(Rails)
+
+      @on_translation_start = lambda { |from, to, length, _timestamp|
+        Rails.logger.info "[MistralTranslator] Starting translation #{from}->#{to} (#{length} chars)"
+      }
+
+      @on_translation_complete = lambda { |from, to, _orig_len, _trans_len, duration|
+        Rails.logger.info "[MistralTranslator] Completed #{from}->#{to} in #{duration.round(2)}s"
+      }
+
+      @on_translation_error = lambda { |from, to, error, attempt, _timestamp|
+        Rails.logger.error "[MistralTranslator] Error #{from}->#{to} (attempt #{attempt}): #{error.message}"
+      }
+
+      @on_rate_limit = lambda { |from, to, wait_time, attempt, _timestamp|
+        Rails.logger.warn "[MistralTranslator] Rate limit #{from}->#{to}, waiting #{wait_time}s (attempt #{attempt})"
+      }
+    end
+
+    private
+
+    def validate_api_url(url)
+      uri = parse_uri(url)
+      validate_uri_scheme(uri, url)
+      validate_uri_host(uri)
+      validate_uri_path(uri)
+      validate_uri_port(uri)
+    end
+
+    def parse_uri(url)
+      require "uri"
+      URI.parse(url)
+    rescue URI::InvalidURIError
+      raise ConfigurationError, "Invalid API URL format: #{url}"
+    end
+
+    def validate_uri_scheme(uri, url)
+      raise ConfigurationError, "Invalid API URL format: #{url}" if uri.scheme.nil?
+      raise ConfigurationError, "API URL must use HTTPS protocol. Got: #{uri.scheme}" unless uri.scheme == "https"
+    end
+
+    def validate_uri_host(uri)
+      return if uri.host == "api.mistral.ai"
+
+      raise ConfigurationError, "Invalid API host. Expected 'api.mistral.ai', got: #{uri.host}"
+    end
+
+    def validate_uri_path(uri)
+      return if uri.path.nil? || uri.path.empty? || uri.path == "/"
+
+      raise ConfigurationError, "Invalid API path. Expected root path, got: #{uri.path}"
+    end
+
+    def validate_uri_port(uri)
+      return if uri.port.nil? || uri.port == 443
+
+      raise ConfigurationError, "Invalid API port. Expected 443 or default, got: #{uri.port}"
+    end
   end
 
   class << self
@@ -35,5 +196,14 @@ module MistralTranslator
     def reset_configuration!
       @configuration = Configuration.new
     end
+
+    # Méthodes utilitaires pour les métriques
+    def metrics
+      configuration.metrics
+    end
+
+    def reset_metrics!
+      configuration.reset_metrics!
+    end
   end
 end

data/lib/mistral_translator/errors.rb

@@ -50,4 +50,20 @@ module MistralTranslator
       super("Unsupported language: #{language}")
     end
   end
+
+  class SecurityError < Error
+    def initialize(message = "Security violation detected")
+      super
+    end
+  end
+
+  class RateLimitExceededError < Error
+    attr_reader :wait_time, :retry_after
+
+    def initialize(message = "Rate limit exceeded", wait_time: nil, retry_after: nil)
+      super(message)
+      @wait_time = wait_time
+      @retry_after = retry_after
+    end
+  end
 end