mistral_translator 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1736f848f5877e51c319bb4584e110e863a6e44464af7f05133d3ea2e2f96fd6
-  data.tar.gz: bd06e5e900f129e662fb2ca90b5c241e55ac86511710d7c4f0cc373fca6c4c2c
+  metadata.gz: 5e52138d192d693042abbc570da3a9ed1f7f56acaed881c46a59df100dc476a0
+  data.tar.gz: 74a169d74c5248dc7ec1cab84c5892018eeacf3ba398bfb0b0a3c41a98d87ae9
 SHA512:
-  metadata.gz: 3f57b5f9652c5b8327de801d5e391eb41f3c6915a9d4551e4ee57a2a61369ead60cffe1c72a5a35ccf089f23401d41d5685480331fe97786d9af7a661c303349
-  data.tar.gz: 672f5aa7932401c2bae6c2ced94058d60ffb6dfab3fb5d6760896f61ed26e5f4eef7b2491697d6680e544b97612f774b4f6fed95b66d0127984d1863592e1509
+  metadata.gz: 3f324d7cb87b75c340d1875fc6189c13c39dfe26c1878ff187c30c04674b88549c813be6f73c644b2b01a5f28ed5e88da55351c86b37800d9648835113f58b3e
+  data.tar.gz: 0d9ac452969b457ed81cd34295e564d869c3e8f254e0807a8d473af8c99fbcb10f0d2ea5bc5abea518a0f7bd59d978428dac8e5c25864c63a4fa61d0dfb1617a

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-12-09
+
+### Added
+
+- Thread-safe metrics with Mutex protection for concurrent usage
+- Connection pooling with net-http-persistent (automatic connection reuse)
+- SSL/TLS configuration options: `ssl_verify_mode`, `ssl_ca_file`, `ssl_ca_path`, `ssl_timeout`
+- Thread-safe logger cache for `warn_once` method
+- Comprehensive concurrent/async documentation with SolidQueue, Sidekiq, Concurrent Ruby examples
+- 39 new tests for thread-safety, SSL configuration, and connection pooling
+
+### Changed
+
+- HTTP client now uses Net::HTTP::Persistent for better performance
+- Configuration metrics now thread-safe across concurrent requests
+- Documentation reorganized with SolidQueue as recommended background job backend
+
+### Performance
+
+- Connection pooling reduces TCP handshake overhead
+- Thread-safe implementation enables safe concurrent translations
+- Configurable SSL timeout for production environments
+
 ## [0.2.0] - 2025-09-09
 
 ### Added

data/CONTRIBUTING.md

@@ -0,0 +1,70 @@
+# Contributing to MistralTranslator
+
+Thank you for your interest in contributing to MistralTranslator! We welcome contributions of all kinds.
+
+## Development Setup
+
+### Prerequisites
+
+- Ruby 3.2+
+- Bundler
+
+### Installation
+
+```bash
+git clone https://github.com/your-username/mistral_translator.git
+cd mistral_translator
+bundle install
+```
+
+## Running Tests
+
+```bash
+# Unit tests (no API key required)
+bundle exec rspec
+
+# Integration tests (requires real API key)
+export MISTRAL_API_KEY=your_key && bundle exec rspec spec/integration/mistral_api_integration_spec.rb
+
+# All tests with coverage
+bundle exec rspec --format documentation
+```
+
+## Contributing Guidelines
+
+### Reporting Issues
+
+- Use GitHub Issues for bug reports and feature requests
+- Include Ruby version, gem version, and relevant code snippets
+- For API-related issues, include sanitized request/response examples
+
+### Pull Requests
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/your-feature`
+3. Make your changes with tests
+4. Ensure all tests pass: `bundle exec rspec`
+5. Follow Ruby style conventions (we use RuboCop - no error) : `bundle exec rubocop`
+6. Submit a pull request with a clear description
+
+### Code Standards
+
+- Write tests for new features and bug fixes
+- Follow existing code patterns and architecture
+- Update documentation for public API changes
+- Keep commits atomic and well-described
+
+### Testing
+
+- Unit tests should not require API calls (use mocks/stubs)
+- Integration tests should use VCR cassettes when possible
+- Test edge cases and error conditions
+- Test coverage must be at 100% (for now)
+
+## Release Process
+
+Releases are handled by maintainers following semantic versioning.
+
+## Questions?
+
+Feel free to open an issue for any questions about contributing.

data/LICENSE.txt

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+MIT License
 
-Copyright (c) 2025 PierreArko
+Copyright (c) 2024 Pierre Cherbero (peyochanchan)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +9,13 @@ 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 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.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -2,8 +2,10 @@
 
 Ruby gem for AI-powered translation and text summarization using Mistral AI API, with advanced Rails support.
 
+[![Ruby](https://img.shields.io/badge/ruby-%23CC342D.svg?style=flat&logo=ruby&logoColor=white)](https://www.ruby-lang.org/)
 [![Gem Version](https://badge.fury.io/rb/mistral_translator.svg)](https://badge.fury.io/rb/mistral_translator)
-
+[![RSpec](https://img.shields.io/badge/tested%20with-RSpec-red.svg)](https://rspec.info/)
+[![RuboCop](https://img.shields.io/badge/code%20style-RuboCop-brightgreen.svg)](https://rubocop.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 ## Quick Start
@@ -30,7 +32,7 @@ MistralTranslator.translate("Bonjour le monde", from: "fr", to: "en")
 - **Multi-level summarization** with translation
 - **Robust error handling** with automatic retry and fallback
 - **Complete monitoring** with metrics and callbacks
-- **Asynchronous jobs** for background processing
+- **Thread-safe & concurrent** with connection pooling ([docs](https://peyochanchan.github.io/mistral_translator/#/advanced-usage/concurrent-async))
 - **Built-in rate limiting** and security
 
 ## Supported Languages
@@ -222,11 +224,11 @@ The complete documentation includes:
 
 ### Quick Links
 
-- [Installation & Setup](https://peyochanchan.github.io/mistral_translator/installation)
-- [Rails Integration Guide](https://peyochanchan.github.io/mistral_translator/rails-integration/)
-- [API Methods Reference](https://peyochanchan.github.io/mistral_translator/api-reference/methods)
-- [Error Handling Guide](https://peyochanchan.github.io/mistral_translator/api-reference/errors)
-- [Monitoring Setup](https://peyochanchan.github.io/mistral_translator/advanced-usage/monitoring)
+- [Installation & Setup](https://peyochanchan.github.io/mistral_translator/#/installation)
+- [Rails Integration Guide](https://peyochanchan.github.io/mistral_translator/#/rails-integration/setup)
+- [API Methods Reference](https://peyochanchan.github.io/mistral_translator/#/api-reference/methods)
+- [Error Handling Guide](https://peyochanchan.github.io/mistral_translator/#/api-reference/errors)
+- [Monitoring Setup](https://peyochanchan.github.io/mistral_translator/#/advanced-usage/monitoring)
 
 ## Requirements
 
@@ -237,14 +239,28 @@ The complete documentation includes:
 ## Testing
 
 ```bash
-# Run tests
-bundle exec rspec
+# Install dependencies
+bundle install
 
-# Run with coverage
-COVERAGE=true bundle exec rspec
+# Run all unit tests (no API key required)
+bundle exec rspec spec/mistral_translator/
 
-# Integration tests (requires API key)
-MISTRAL_API_KEY=your_key bundle exec rspec --tag integration
+# Run all tests with documentation format
+bundle exec rspec --format documentation
+```
+
+### Integration Tests
+
+Integration tests require a real Mistral API key. **Never commit API keys to version control.**
+
+```bash
+# Set API key via environment variable (recommended)
+export MISTRAL_API_KEY="your_api_key_here"
+
+# Run integration tests
+bundle exec rspec spec/integration/
+
+**Security Note:** Use a dedicated test API key with limited quotas for integration testing.
 ```
 
 ## Contributing
@@ -259,15 +275,24 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed guidelines.
 
 ## License
 
-MIT License. See [LICENSE](LICENSE) for details.
+MIT License. See [LICENSE](LICENSE.txt) for details.
 
 ## Support
 
 - 📖 [Documentation](https://peyochanchan.github.io/mistral_translator/)
 - 🐛 [Issues](../../issues)
-- 💬 [Discussions](../../discussions)
 - 📧 Support: Create an issue for help
 
+### ☕ Support the Project
+
+If this gem helps you, consider supporting its development:
+
+[![Buy Me A Coffee](https://img.shields.io/badge/Buy%20Me%20A%20Coffee-FFDD00?style=for-the-badge&logo=buy-me-a-coffee&logoColor=black)](https://buymeacoffee.com/peyochanchan)
+
 ---
 
 Built with Ruby ❤️ by [@peyochanchan](https://github.com/peyochanchan)
+
+```
+
+```

data/docs/advanced-usage/concurrent-async.md

@@ -0,0 +1,270 @@
+# Concurrent & Asynchronous Processing
+
+MistralTranslator is thread-safe and optimized for concurrent usage with protected metrics, connection pooling, and built-in rate limiting.
+
+## Thread Safety
+
+**Protected components:**
+- Metrics tracking with Mutex
+- Logger cache with concurrent access control
+- Rate limiter with thread synchronization
+- HTTP connection pooling (Net::HTTP::Persistent)
+
+## Ruby Threads
+
+### Basic Usage
+
+```ruby
+languages = ['fr', 'es', 'de', 'it']
+threads = languages.map do |lang|
+  Thread.new do
+    MistralTranslator.translate("Hello", from: 'en', to: lang)
+  rescue MistralTranslator::Error => e
+    { error: e.message }
+  end
+end
+
+results = threads.map(&:value)
+```
+
+### Thread Pool Pattern
+
+```ruby
+# Safe: Limited threads
+texts.each_slice(5) do |batch|
+  threads = batch.map { |t| Thread.new { translate(t) } }
+  threads.each(&:join)
+end
+
+# Dangerous: Unlimited threads can exhaust memory
+texts.map { |t| Thread.new { translate(t) } }  # Avoid this
+```
+
+## Concurrent Ruby (Recommended)
+
+### Installation
+
+```ruby
+# Gemfile
+gem 'concurrent-ruby', '~> 1.2'
+```
+
+### Fixed Thread Pool
+
+```ruby
+require 'concurrent'
+
+pool = Concurrent::FixedThreadPool.new(5)
+
+futures = languages.map do |lang|
+  Concurrent::Future.execute(executor: pool) do
+    MistralTranslator.translate(text, from: 'en', to: lang)
+  end
+end
+
+results = futures.map(&:value)
+
+pool.shutdown
+pool.wait_for_termination
+```
+
+### Promise Chains
+
+```ruby
+promise = Concurrent::Promise.execute do
+  MistralTranslator.translate_auto(text, to: 'en')
+end.then do |english|
+  target_langs.map do |lang|
+    MistralTranslator.translate(english, from: 'en', to: lang)
+  end
+end.rescue do |error|
+  Rails.logger.error "Pipeline failed: #{error}"
+  []
+end
+
+results = promise.value
+```
+
+## Background Jobs
+
+### SolidQueue (Rails 8+, Recommended)
+
+SolidQueue is the default ActiveJob backend in Rails 8, database-backed and Redis-free.
+
+```ruby
+# config/database.yml - SolidQueue uses your existing database
+production:
+  primary:
+    <<: *default
+  queue:  # Separate DB for jobs (optional)
+    <<: *default
+    database: app_queue
+    migrations_paths: db/queue_migrate
+
+# app/jobs/translation_job.rb
+class TranslationJob < ApplicationJob
+  queue_as :translations
+
+  retry_on MistralTranslator::RateLimitError, wait: :polynomially_longer
+  retry_on MistralTranslator::ApiError, wait: 5.seconds, attempts: 3
+
+  def perform(text, from_locale, to_locale)
+    MistralTranslator.translate(text, from: from_locale, to: to_locale)
+  end
+end
+
+# Usage
+languages.each { |lang| TranslationJob.perform_later(text, 'en', lang) }
+```
+
+**Configuration:**
+```ruby
+# config/recurring.yml - Schedule periodic translations
+production:
+  sync_translations:
+    class: TranslationSyncJob
+    schedule: every day at 3am
+    queue: translations
+```
+
+### Sidekiq / Other Backends
+
+Compatible with any ActiveJob backend:
+
+```ruby
+class TranslationJob < ApplicationJob
+  queue_as :translations
+  retry_on MistralTranslator::RateLimitError, wait: :exponentially_longer
+
+  def perform(text, from, to)
+    MistralTranslator.translate(text, from: from, to: to)
+  end
+end
+```
+
+## Performance Best Practices
+
+### Configuration for Concurrent Use
+
+```ruby
+MistralTranslator.configure do |config|
+  config.enable_metrics = true
+  config.retry_delays = [1, 2, 4, 8]  # Shorter for concurrent use
+
+  config.on_rate_limit = ->(from, to, wait, attempt, ts) {
+    Rails.logger.warn "Rate limit: #{wait}s wait"
+  }
+end
+```
+
+### Recommendations
+
+**Do:**
+- Use fixed thread pools (5-10 threads)
+- Enable metrics for monitoring
+- Use background jobs for non-critical tasks
+- Batch similar requests
+
+**Avoid:**
+- Unlimited thread creation
+- Blocking user requests with translations
+- Sharing API keys across environments
+
+## Rate Limiting
+
+The built-in rate limiter (50 requests/60s) is thread-safe but per-process.
+
+**Multiple processes:** Each has its own limiter. With 4 Puma workers = 200 requests/min total.
+
+### Custom Rate Limiter
+
+```ruby
+class RedisRateLimiter
+  def wait_and_record!
+    key = "mistral:#{Time.now.to_i / 60}"
+    count = REDIS.incr(key)
+    REDIS.expire(key, 60) if count == 1
+
+    sleep(60 - Time.now.to_i % 60) if count > 50
+  end
+end
+
+client = MistralTranslator::Client.new(
+  rate_limiter: RedisRateLimiter.new
+)
+```
+
+## Monitoring
+
+```ruby
+MistralTranslator.configure do |config|
+  config.enable_metrics = true
+
+  config.on_translation_complete = ->(from, to, orig, trans, duration) {
+    Rails.logger.info "[#{Thread.current.object_id}] #{from}→#{to}: #{duration.round(2)}s"
+  }
+end
+
+# Thread-safe metrics
+metrics = MistralTranslator.metrics
+puts "Total: #{metrics[:total_translations]}"
+puts "Avg time: #{metrics[:average_translation_time]}s"
+puts "Error rate: #{metrics[:error_rate]}%"
+```
+
+## Example: High-Performance Service
+
+```ruby
+class TranslationService
+  def initialize(max_threads: 5)
+    @pool = Concurrent::FixedThreadPool.new(max_threads)
+  end
+
+  def translate_all(texts, from:, to_languages:)
+    futures = texts.flat_map do |text|
+      to_languages.map do |lang|
+        Concurrent::Future.execute(executor: @pool) do
+          MistralTranslator.translate(text, from: from, to: lang)
+        end
+      end
+    end
+    futures.map(&:value)
+  ensure
+    @pool.shutdown
+    @pool.wait_for_termination(30)
+  end
+end
+```
+
+## Troubleshooting
+
+**"Too many open files"**
+```bash
+ulimit -n 4096
+```
+
+**Rate limits despite low volume**
+Check if multiple processes share the API key. Consider Redis-based rate limiting.
+
+**Memory growth**
+```ruby
+# Join threads periodically
+threads = []
+texts.each do |text|
+  threads << Thread.new { translate(text) }
+
+  if threads.size >= 10
+    threads.each(&:join)
+    threads.clear
+  end
+end
+```
+
+## Summary
+
+- Thread-safe with protected metrics and configuration
+- Connection pooling automatic with net-http-persistent
+- Use fixed-size thread pools (5-10 recommended)
+- Built-in rate limiting works across threads
+- Background jobs recommended for non-critical tasks
+- Separate API keys per environment

data/lib/mistral_translator/client_helpers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "net/http/persistent"
+
 module MistralTranslator
   module ClientHelpers
     # Helper pour la gestion des requêtes HTTP
@@ -9,14 +11,10 @@ module MistralTranslator
 
         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)
+        response = http_pool.request(uri, request)
         log_request_response(request_body, response)
 
         response
@@ -26,6 +24,38 @@ module MistralTranslator
         raise ApiError, "HTTP error: #{e.message}"
       end
 
+      def http_pool
+        @http_pool ||= begin
+          pool = Net::HTTP::Persistent.new(name: "mistral_translator")
+          pool.read_timeout = 60
+          pool.idle_timeout = 30
+          pool.open_timeout = MistralTranslator.configuration.ssl_timeout
+          pool.max_requests = 100
+
+          # SSL/TLS configuration
+          configure_ssl(pool)
+
+          pool
+        end
+      end
+
+      def configure_ssl(pool)
+        config = MistralTranslator.configuration
+
+        # SSL verify mode
+        pool.verify_mode = case config.ssl_verify_mode
+                           when :peer then OpenSSL::SSL::VERIFY_PEER
+                           when :none then OpenSSL::SSL::VERIFY_NONE
+                           else config.ssl_verify_mode
+                           end
+
+        # Custom CA certificate file
+        pool.ca_file = config.ssl_ca_file if config.ssl_ca_file
+
+        # Custom CA certificates directory
+        pool.ca_path = config.ssl_ca_path if config.ssl_ca_path
+      end
+
       def build_request_body(prompt, max_tokens, temperature)
         body = {
           model: @model,

data/lib/mistral_translator/configuration.rb

@@ -4,7 +4,8 @@ module MistralTranslator
   class Configuration
     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
+                  :on_rate_limit, :on_batch_complete, :enable_metrics,
+                  :ssl_verify_mode, :ssl_ca_file, :ssl_ca_path, :ssl_timeout
     attr_reader :api_url
 
     def initialize
@@ -23,7 +24,14 @@ module MistralTranslator
       @on_batch_complete = nil
       @enable_metrics = false
 
-      # Métriques intégrées
+      # SSL/TLS configuration
+      @ssl_verify_mode = :peer  # :peer, :none, or OpenSSL constant
+      @ssl_ca_file = nil        # Path to CA certificate file
+      @ssl_ca_path = nil        # Path to CA certificates directory
+      @ssl_timeout = 60         # SSL handshake timeout in seconds
+
+      # Métriques intégrées (thread-safe avec mutex)
+      @metrics_mutex = Mutex.new
       @metrics = {
         total_translations: 0,
         total_characters: 0,
@@ -54,9 +62,11 @@ module MistralTranslator
 
       return unless @enable_metrics
 
-      @metrics[:total_translations] += 1
-      @metrics[:total_characters] += text_length
-      @metrics[:translations_by_language]["#{from_locale}->#{to_locale}"] += 1
+      @metrics_mutex.synchronize do
+        @metrics[:total_translations] += 1
+        @metrics[:total_characters] += text_length
+        @metrics[:translations_by_language]["#{from_locale}->#{to_locale}"] += 1
+      end
     end
 
     def trigger_translation_complete(from_locale, to_locale, original_length, translated_length, duration)
@@ -64,7 +74,9 @@ module MistralTranslator
 
       return unless @enable_metrics
 
-      @metrics[:total_duration] += duration
+      @metrics_mutex.synchronize do
+        @metrics[:total_duration] += duration
+      end
     end
 
     def trigger_translation_error(from_locale, to_locale, error, attempt)
@@ -72,7 +84,9 @@ module MistralTranslator
 
       return unless @enable_metrics
 
-      @metrics[:errors_count] += 1
+      @metrics_mutex.synchronize do
+        @metrics[:errors_count] += 1
+      end
     end
 
     def trigger_rate_limit(from_locale, to_locale, wait_time, attempt)
@@ -80,7 +94,9 @@ module MistralTranslator
 
       return unless @enable_metrics
 
-      @metrics[:rate_limits_hit] += 1
+      @metrics_mutex.synchronize do
+        @metrics[:rate_limits_hit] += 1
+      end
     end
 
     def trigger_batch_complete(batch_size, total_duration, success_count, error_count)
@@ -91,35 +107,39 @@ module MistralTranslator
     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
-                     })
+      @metrics_mutex.synchronize do
+        @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
     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)
-      }
+      @metrics_mutex.synchronize do
+        @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
     end
 
     # Configuration helpers pour les callbacks les plus communs

data/lib/mistral_translator/logger.rb

@@ -17,12 +17,15 @@ module MistralTranslator
 
       # Log seulement si pas déjà loggé récemment (évite la spam)
       def warn_once(message, key: nil, sensitive: false, ttl: 300)
-        @warn_cache ||= {}
-        cache_key = key || message
+        cache_mutex.synchronize do
+          @warn_cache ||= {}
+          cache_key = key || message
 
-        return unless should_log_warning?(cache_key, ttl)
+          return unless should_log_warning?(cache_key, ttl)
+
+          @warn_cache[cache_key] = Time.now
+        end
 
-        @warn_cache[cache_key] = Time.now
         log(:warn, message, sensitive)
       end
 
@@ -74,6 +77,10 @@ module MistralTranslator
 
         Time.now - @warn_cache[key] > ttl
       end
+
+      def cache_mutex
+        @cache_mutex ||= Mutex.new
+      end
     end
   end
 end

data/lib/mistral_translator/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MistralTranslator
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 
   # Informations additionnelles sur la gem
   API_VERSION = "v1"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mistral_translator
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Peyochanchan
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +122,7 @@ files:
 - ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
 - LICENSE.txt
 - README.md
 - README_TESTING.md
@@ -117,6 +132,7 @@ files:
 - docs/404.html
 - docs/README.md
 - docs/advanced-usage/batch-processing.md
+- docs/advanced-usage/concurrent-async.md
 - docs/advanced-usage/error-handling.md
 - docs/advanced-usage/monitoring.md
 - docs/advanced-usage/summarization.md