rack-smart_compress 0.1.0

data/lib/rack/smart_compress/middleware.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require_relative "configuration"
+require_relative "encoders/base"
+require_relative "encoders/zstd"
+require_relative "encoders/brotli"
+require_relative "encoders/gzip"
+require_relative "encoders/deflate"
+require_relative "lru_cache"
+require_relative "stream_body"
+require_relative "cpu_advisor"
+
+module Rack
+  module SmartCompress
+    class Middleware
+      ENCODERS = {
+        "zstd" => Encoders::Zstd,
+        "br" => Encoders::Brotli,
+        "gzip" => Encoders::Gzip,
+        "deflate" => Encoders::Deflate
+      }.freeze
+
+      attr_reader :app, :options, :cache
+
+      def initialize(app, options = {})
+        @app = app
+        default_config = Rack::SmartCompress.configuration.to_h
+        @options = default_config.merge(options)
+
+        @min_size = @options.fetch(:min_size, Configuration::DEFAULT_MIN_SIZE)
+        @mime_types = @options.fetch(:mime_types, Configuration::DEFAULT_MIME_TYPES)
+        @exclude_mime_types = @options.fetch(:exclude_mime_types, Configuration::DEFAULT_EXCLUDED_MIME_TYPES)
+        @enabled_encodings = @options.fetch(:encodings, Configuration::DEFAULT_ENCODINGS)
+        @if_condition = @options[:if]
+        @unless_condition = @options[:unless]
+        @dynamic_levels = @options.fetch(:dynamic_levels, false)
+        @instrumentation = @options.fetch(:instrumentation, true)
+
+        if @options[:cache] || @options[:cache_size]
+          cache_size = @options.is_a?(Integer) ? @options[:cache_size] : (@options[:cache_size] || LruCache::DEFAULT_MAX_SIZE)
+          @cache = LruCache.new(cache_size)
+        else
+          @cache = nil
+        end
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+
+        return [status, headers, body] if no_body_status?(status)
+        return [status, headers, body] if already_encoded?(headers)
+        return [status, headers, body] if no_transform?(headers)
+        return [status, headers, body] if partial_content?(status, headers)
+        return [status, headers, body] unless custom_rules_pass?(env, status, headers)
+
+        accept_encoding = env["HTTP_ACCEPT_ENCODING"].to_s
+        encoder_name, encoder_class = negotiate_encoder(accept_encoding)
+        return [status, headers, body] unless encoder_class
+
+        content_type = get_header(headers, "content-type")
+        return [status, headers, body] unless compressible_mime_type?(content_type)
+
+        level = options[:"#{encoder_name}_level"]
+        level = CpuAdvisor.adjusted_level(encoder_name, level) if @dynamic_levels
+
+        # Handle streaming responses
+        if streaming_body?(body) || options[:stream]
+          new_headers = headers.dup
+          set_header(new_headers, "content-encoding", encoder_name)
+          delete_header(new_headers, "content-length") # Chunked stream size is dynamic
+          append_vary(new_headers, "Accept-Encoding")
+          weaken_etag(new_headers)
+          stream_wrapper = StreamBody.new(body, encoder_name, encoder_class, level: level)
+          return [status, new_headers, stream_wrapper]
+        end
+
+        body_string = extract_body_string(body)
+        return [status, headers, body] if body_string.bytesize < @min_size
+
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        compressed_body, compressed_size, cache_hit = compress_with_cache(encoder_name, encoder_class, level, body_string)
+        duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000.0).round(3)
+
+        body.close if body.respond_to?(:close)
+
+        new_headers = headers.dup
+        set_header(new_headers, "content-encoding", encoder_name)
+        set_header(new_headers, "content-length", compressed_size.to_s)
+        append_vary(new_headers, "Accept-Encoding")
+        weaken_etag(new_headers)
+
+        record_telemetry(encoder_name, body_string.bytesize, compressed_size, duration_ms, cache_hit, env)
+
+        [status, new_headers, compressed_body]
+      end
+
+      private
+
+      def custom_rules_pass?(env, status, headers)
+        if @if_condition.respond_to?(:call)
+          return false unless @if_condition.call(env, status, headers)
+        end
+
+        if @unless_condition.respond_to?(:call)
+          return false if @unless_condition.call(env, status, headers)
+        end
+
+        true
+      end
+
+      def compress_with_cache(encoder_name, encoder_class, level, body_string)
+        if @cache
+          cache_key = @cache.build_key(encoder_name, level, body_string)
+          cache_hit = true
+          cached_result = @cache.get(cache_key)
+
+          if cached_result.nil?
+            cache_hit = false
+            res = encoder_class.encode_body(body_string, level: level)
+            cached_result = [res, res.first.bytesize]
+            @cache.put(cache_key, cached_result)
+          end
+
+          [cached_result[0], cached_result[1], cache_hit]
+        else
+          res = encoder_class.encode_body(body_string, level: level)
+          [res, res.first.bytesize, false]
+        end
+      end
+
+      def record_telemetry(encoder_name, original_size, compressed_size, duration_ms, cache_hit, env)
+        return unless @instrumentation
+
+        payload = {
+          encoder: encoder_name,
+          original_size: original_size,
+          compressed_size: compressed_size,
+          duration_ms: duration_ms,
+          cache_hit: cache_hit,
+          path: env["PATH_INFO"]
+        }
+
+        if defined?(ActiveSupport::Notifications)
+          ActiveSupport::Notifications.instrument("rack_smart_compress.compress", payload)
+        end
+
+        if @instrumentation.respond_to?(:call)
+          @instrumentation.call(payload)
+        end
+      end
+
+      def streaming_body?(body)
+        return false if body.is_a?(Array)
+        return false if body.respond_to?(:to_ary)
+        return false if body.respond_to?(:to_str)
+
+        if defined?(Rack::BodyProxy) && body.is_a?(Rack::BodyProxy)
+          target = body.instance_variable_get(:@body)
+          if target
+            return false if target.is_a?(Array) || target.respond_to?(:to_ary) || target.respond_to?(:to_str)
+          end
+        end
+
+        body.respond_to?(:each)
+      end
+
+      def no_body_status?(status)
+        status < 200 || status == 204 || status == 205 || status == 304
+      end
+
+      def partial_content?(status, headers)
+        status == 206 || !get_header(headers, "content-range").nil?
+      end
+
+      def no_transform?(headers)
+        cache_control = get_header(headers, "cache-control")
+        cache_control && cache_control.downcase.include?("no-transform")
+      end
+
+      def already_encoded?(headers)
+        !get_header(headers, "content-encoding").nil?
+      end
+
+      def weaken_etag(headers)
+        etag = get_header(headers, "etag")
+        if etag && !etag.empty? && !etag.start_with?("W/")
+          set_header(headers, "etag", %(W/#{etag}))
+        end
+      end
+
+      def compressible_mime_type?(content_type)
+        return false if content_type.nil? || content_type.empty?
+
+        type = content_type.split(";").first.to_s.strip.downcase
+
+        return false if @exclude_mime_types.any? { |ex| type.start_with?(ex) || type.include?(ex) }
+
+        @mime_types.any? { |mime| type == mime || type.start_with?(mime) } ||
+          type.end_with?("+json") || type.end_with?("+xml")
+      end
+
+      def negotiate_encoder(accept_encoding)
+        return [nil, nil] if accept_encoding.strip.empty?
+
+        requested, disallowed = parse_accept_encoding(accept_encoding)
+
+        # 1. First check explicit requested encodings by q-value
+        requested.each do |enc, q_val|
+          next unless q_val > 0.0
+
+          if enc == "*"
+            # Wildcard: pick first available enabled encoding not explicitly disallowed
+            @enabled_encodings.each do |candidate|
+              next if disallowed.include?(candidate)
+              encoder_class = ENCODERS[candidate]
+              return [candidate, encoder_class] if encoder_class&.available?
+            end
+          elsif @enabled_encodings.include?(enc) && !disallowed.include?(enc)
+            encoder_class = ENCODERS[enc]
+            return [enc, encoder_class] if encoder_class&.available?
+          end
+        end
+
+        [nil, nil]
+      end
+
+      def parse_accept_encoding(header)
+        encodings = {}
+        disallowed = []
+
+        header.split(",").each do |part|
+          next if part.strip.empty?
+
+          enc, qval = part.split(";").map(&:strip)
+          next unless enc
+
+          q = 1.0
+          if qval && qval.start_with?("q=")
+            q = qval.sub("q=", "").to_f rescue 1.0
+          end
+
+          enc_down = enc.downcase
+          if q <= 0.0
+            disallowed << enc_down
+          else
+            encodings[enc_down] = q
+          end
+        end
+
+        [encodings.sort_by { |_, q| -q }.to_h, disallowed]
+      end
+
+      def extract_body_string(body)
+        buffer = String.new
+        if body.respond_to?(:each)
+          body.each { |part| buffer << part.to_s }
+        else
+          buffer << body.to_s
+        end
+        buffer
+      end
+
+      def get_header(headers, name)
+        return headers[name] if headers.key?(name)
+
+        down_name = name.downcase
+        headers.each do |key, value|
+          return value if key.to_s.downcase == down_name
+        end
+        nil
+      end
+
+      def set_header(headers, name, value)
+        matching_key = headers.keys.find { |k| k.to_s.downcase == name.downcase } || name
+        headers[matching_key] = value
+      end
+
+      def delete_header(headers, name)
+        matching_key = headers.keys.find { |k| k.to_s.downcase == name.downcase }
+        headers.delete(matching_key) if matching_key
+      end
+
+      def append_vary(headers, vary_val)
+        current = get_header(headers, "vary")
+        if current.nil? || current.empty?
+          set_header(headers, "vary", vary_val)
+        elsif !current.split(",").map(&:strip).include?(vary_val)
+          set_header(headers, "vary", "#{current}, #{vary_val}")
+        end
+      end
+    end
+  end
+end

data/lib/rack/smart_compress/railtie.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rack
+  module SmartCompress
+    class Railtie < ::Rails::Railtie
+      config.smart_compress = Configuration.new
+
+      initializer "rack_smart_compress.insert_middleware" do |app|
+        options = app.config.smart_compress.to_h
+
+        # If static assets enabled or public directory exists, insert Static before ActionDispatch::Static
+        if options[:static_assets]
+          static_options = {
+            root: options[:static_root] || app.paths["public"].first,
+            urls: options[:static_urls] || ["/"],
+            headers: options[:static_headers] || {},
+            cascade: options[:static_cascade] != false
+          }
+
+          if defined?(ActionDispatch::Static) && app.middleware.include?(ActionDispatch::Static)
+            app.middleware.insert_before ActionDispatch::Static, Rack::SmartCompress::Static, static_options
+          else
+            app.middleware.use Rack::SmartCompress::Static, static_options
+          end
+        end
+
+        if defined?(ActionDispatch::Static) && app.middleware.include?(ActionDispatch::Static)
+          app.middleware.insert_after ActionDispatch::Static, Rack::SmartCompress::Middleware, options
+        else
+          app.middleware.use Rack::SmartCompress::Middleware, options
+        end
+      end
+    end
+  end
+end if defined?(::Rails::Railtie)

data/lib/rack/smart_compress/static.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "rack/mime"
+require "rack/utils"
+require "time"
+
+module Rack
+  module SmartCompress
+    class Static
+      DEFAULT_EXTENSIONS = {
+        "zstd" => ".zst",
+        "br"   => ".br",
+        "gzip" => ".gz"
+      }.freeze
+
+      class FileBody
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        def each
+          File.open(@path, "rb") do |file|
+            while (chunk = file.read(16_384))
+              yield chunk
+            end
+          end
+        end
+
+        def to_path
+          @path
+        end
+      end
+
+      attr_reader :app, :root, :urls, :encodings, :headers, :cascade
+
+      def initialize(app, options = {})
+        @app = app
+        @root = File.expand_path(options.fetch(:root, "public"))
+        @urls = Array(options.fetch(:urls, ["/"])).map(&:to_s)
+        @encodings = options.fetch(:encodings, DEFAULT_EXTENSIONS)
+        @headers = options.fetch(:headers, {})
+        @cascade = options.fetch(:cascade, true)
+      end
+
+      def call(env)
+        method = env["REQUEST_METHOD"]
+        return @app.call(env) unless %w[GET HEAD].include?(method)
+
+        path_info = env["PATH_INFO"].to_s
+        return @app.call(env) unless url_match?(path_info)
+
+        clean_path = Rack::Utils.clean_path_info(path_info)
+        full_path = File.join(@root, clean_path)
+
+        # Path traversal guard: ensure path is strictly inside @root
+        return @app.call(env) unless safe_path?(full_path)
+
+        accept_encoding = env["HTTP_ACCEPT_ENCODING"].to_s
+        encoding, compressed_path = find_precompressed_file(full_path, accept_encoding)
+
+        if compressed_path
+          serve_file(env, full_path, compressed_path, encoding, method)
+        elsif File.file?(full_path) && !@cascade
+          serve_file(env, full_path, full_path, nil, method)
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def url_match?(path)
+        @urls.any? { |url| url == "/" || path.start_with?(url) }
+      end
+
+      def safe_path?(path)
+        expanded = File.expand_path(path)
+        expanded == @root || expanded.start_with?("#{@root}/")
+      end
+
+      def find_precompressed_file(base_path, accept_encoding)
+        return [nil, nil] if accept_encoding.strip.empty?
+
+        accepted = parse_accepted_encodings(accept_encoding)
+
+        accepted.each do |enc|
+          ext = @encodings[enc]
+          next unless ext
+
+          candidate_path = "#{base_path}#{ext}"
+          return [enc, candidate_path] if File.file?(candidate_path)
+        end
+
+        [nil, nil]
+      end
+
+      def parse_accepted_encodings(header)
+        encodings = {}
+        header.split(",").each do |part|
+          next if part.strip.empty?
+
+          enc, qval = part.split(";").map(&:strip)
+          next unless enc
+
+          q = 1.0
+          if qval && qval.start_with?("q=")
+            q = qval.sub("q=", "").to_f rescue 1.0
+          end
+
+          encodings[enc.downcase] = q if q > 0.0
+        end
+
+        encodings.sort_by { |_, q| -q }.map(&:first)
+      end
+
+      def serve_file(env, original_path, served_path, encoding, method)
+        stat = File.stat(served_path)
+        mtime = stat.mtime.httpdate
+        etag = %(W/"#{stat.mtime.to_i.to_s(16)}-#{stat.size.to_s(16)}")
+
+        # Conditional GET checks
+        if_none_match = env["HTTP_IF_NONE_MATCH"]
+        if_modified_since = env["HTTP_IF_MODIFIED_SINCE"]
+
+        if if_none_match && if_none_match == etag
+          return [304, build_headers(original_path, stat, encoding, mtime, etag), []]
+        end
+
+        if if_modified_since
+          begin
+            since_time = Time.httpdate(if_modified_since)
+            if stat.mtime <= since_time
+              return [304, build_headers(original_path, stat, encoding, mtime, etag), []]
+            end
+          rescue ArgumentError
+            # Invalid date format in header, proceed with full response
+          end
+        end
+
+        res_headers = build_headers(original_path, stat, encoding, mtime, etag)
+        body = method == "HEAD" ? [] : FileBody.new(served_path)
+
+        [200, res_headers, body]
+      end
+
+      def build_headers(original_path, stat, encoding, mtime, etag)
+        ext = File.extname(original_path)
+        mime_type = Rack::Mime.mime_type(ext, "application/octet-stream")
+
+        headers = {
+          "content-type"   => mime_type,
+          "content-length" => stat.size.to_s,
+          "last-modified"  => mtime,
+          "etag"           => etag,
+          "vary"           => "Accept-Encoding"
+        }
+
+        headers["content-encoding"] = encoding if encoding
+
+        @headers.each do |key, value|
+          headers[key.to_s.downcase] = value
+        end
+
+        headers
+      end
+    end
+  end
+end

data/lib/rack/smart_compress/stream_body.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "zlib"
+
+module Rack
+  module SmartCompress
+    class StreamBody
+      attr_reader :body, :encoder_name, :encoder_class, :level
+
+      def initialize(body, encoder_name, encoder_class, level: nil)
+        @body = body
+        @encoder_name = encoder_name
+        @encoder_class = encoder_class
+        @level = level
+        @closed = false
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block_given?
+
+        begin
+          case encoder_name
+          when "gzip"
+            stream_gzip(&block)
+          when "deflate"
+            stream_deflate(&block)
+          when "zstd"
+            stream_zstd(&block)
+          when "br"
+            stream_brotli(&block)
+          else
+            @body.each { |chunk| yield encoder_class.compress(chunk.to_s, level: level) }
+          end
+        ensure
+          close
+        end
+      end
+
+      def close
+        return if @closed
+
+        @closed = true
+        @body.close if @body.respond_to?(:close)
+      end
+
+      private
+
+      def stream_gzip
+        io = StringIO.new
+        io.set_encoding(Encoding::BINARY)
+        writer = Zlib::GzipWriter.new(io, level || Zlib::DEFAULT_COMPRESSION)
+
+        @body.each do |chunk|
+          chunk_str = chunk.to_s
+          next if chunk_str.empty?
+
+          writer.write(chunk_str)
+          writer.flush
+          data = io.string.dup
+          io.truncate(0)
+          io.rewind
+          yield data unless data.empty?
+        end
+
+        writer.close
+        final_data = io.string
+        yield final_data unless final_data.empty?
+      end
+
+      def stream_deflate
+        deflater = Zlib::Deflate.new(level || Zlib::DEFAULT_COMPRESSION)
+
+        @body.each do |chunk|
+          chunk_str = chunk.to_s
+          next if chunk_str.empty?
+
+          data = deflater.deflate(chunk_str, Zlib::SYNC_FLUSH)
+          yield data unless data.empty?
+        end
+
+        final_data = deflater.finish
+        yield final_data unless final_data.empty?
+        deflater.close
+      end
+
+      def stream_zstd
+        if defined?(::Zstd::StreamingCompress)
+          compressor = ::Zstd::StreamingCompress.new(level: level || 3)
+          @body.each do |chunk|
+            chunk_str = chunk.to_s
+            next if chunk_str.empty?
+
+            data = compressor.compress(chunk_str)
+            yield data unless data.nil? || data.empty?
+          end
+          final_data = compressor.finish
+          yield final_data unless final_data.nil? || final_data.empty?
+        else
+          buffer = String.new
+          @body.each { |chunk| buffer << chunk.to_s }
+          yield encoder_class.compress(buffer, level: level)
+        end
+      end
+
+      def stream_brotli
+        if defined?(::Brotli::Compressor)
+          compressor = ::Brotli::Compressor.new(quality: level || 4)
+          @body.each do |chunk|
+            chunk_str = chunk.to_s
+            next if chunk_str.empty?
+
+            data = compressor.process(chunk_str)
+            yield data unless data.nil? || data.empty?
+          end
+          final_data = compressor.finish
+          yield final_data unless final_data.nil? || final_data.empty?
+        else
+          buffer = String.new
+          @body.each { |chunk| buffer << chunk.to_s }
+          yield encoder_class.compress(buffer, level: level)
+        end
+      end
+    end
+  end
+end

data/lib/rack/smart_compress/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rack
+  module SmartCompress
+    VERSION = "0.1.0"
+  end
+end

data/lib/rack/smart_compress.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "smart_compress/version"
+require_relative "smart_compress/configuration"
+require_relative "smart_compress/middleware"
+require_relative "smart_compress/static"
+require_relative "smart_compress/railtie" if defined?(Rails)
+
+module Rack
+  module SmartCompress
+    class << self
+      def new(app, options = {})
+        Middleware.new(app, options)
+      end
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration) if block_given?
+        configuration
+      end
+
+      def reset_config!
+        @configuration = Configuration.new
+      end
+    end
+  end
+end