jekyll-minify 1.0.8 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf13427398f4a1d4d2571367ac83d24d8bb41be50f2f3d2e71b5b446c8e1e491
-  data.tar.gz: c4cfe9a1ef18183832646894e5fc73346085f1e96d2de77d309e13370c3be741
+  metadata.gz: f3cca42f128bfb722359fbe7cad0782cdde8192bc1dbadc889ab09de710e0fba
+  data.tar.gz: bba9d326f421608eb24d4d4613947b1ca4427d5a7ef3a599c66c193722d52fe6
 SHA512:
-  metadata.gz: aa89fd52f46081b6f350ca763fcd2bc513b88a1a0a385b71038bafea9a228b92cc0aabeee3e75d490466fc1f39dfe2471c4cf9245cc196fabac4fa8a47ceb108
-  data.tar.gz: 475f8e2578103875942cfbd7467622fa20d5e89be682f27749022708277caa71606935840fcbb0b669ecd119cfb6899075fe544b8b0d2ccf63a7ec3b32f1b31b
+  metadata.gz: 8f0826508130a2f2c2ddb1c8a26799412c82752b49066282ceb279526a505f86d91209b88230362bfdc02e53f0b9835df33f6843d49ad797c14591b56f88e013
+  data.tar.gz: d3caa8d83001eafc4ada3ab56e6c9210e415af5478892fc255a5d8a6589e4ff0b7f978e82dcd991288b88197519be1f7325a9ad57be34df57ba8e4a69bee7ca9

data/lib/jekyll-minify/instrumentation.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Minify
+    # OpenTelemetry instrumentation facade for jekyll-minify.
+    #
+    # All tracing is configured centrally in TRACED_METHODS — no span code lives
+    # in business logic classes. To add a span: append one entry. To rename a
+    # method: update the one entry. When a method is removed from its class the
+    # stale entry raises NoMethodError in tests, signalling the entry to delete.
+    #
+    # Requires opentelemetry-api at runtime; falls back to a no-op if absent.
+    # Users opt in to real tracing by adding opentelemetry-sdk and
+    # opentelemetry-exporter-otlp to their site Gemfile and exporting:
+    #
+    #   OTEL_SERVICE_NAME=jekyll-minify
+    #   OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+    module Instrumentation
+      # Name reported to the OTel tracer provider for spans created by this gem.
+      #
+      # @return [String]
+      TRACER_NAME = 'jekyll-minify'
+
+      # Central instrumentation registry.
+      #
+      # Each row: [class_name, method_type, method_name, span_name, attribute_proc]
+      #
+      # method_type:
+      #   :instance  — public instance method
+      #   :private   — private instance method (visibility is preserved on the wrapper)
+      #   :class     — class / module method (prepended on the singleton class)
+      #
+      # attribute_proc: ->(span, this, args, result) or nil
+      #   span   — OTel span (or NoopSpan); call span.set_attribute after super returns
+      #   this   — receiver object (instance or nil for class methods)
+      #   args   — positional args array as passed to the method
+      #   result — return value of the original method
+      #
+      # @return [Array<Array>]
+      # :nocov: — attribute procs are configuration data; coverage comes from integration tests
+      TRACED_METHODS = [
+        ['Jekyll::Minify::Minifier', :class, :minify_site, 'minify.site_minify',
+         lambda { |span, _this, args, result|
+           span.set_attribute('minify.dest_path', args[0].dest.to_s)
+           next unless result
+
+           types = result.values_at(:html, :css, :js)
+           span.set_attribute('minify.total_file_count', types.sum { |t| t[:count] })
+           span.set_attribute('minify.total_original_size_bytes', types.sum { |t| t[:original_bytes] })
+           span.set_attribute('minify.total_minified_size_bytes', types.sum { |t| t[:minified_bytes] })
+           span.set_attribute('minify.error_count', result[:errors].length)
+         }],
+
+        ['Jekyll::Minify::Minifier', :private, :minify_each_file, 'minify.file_discovery',
+         lambda { |span, _this, args, _result|
+           span.set_attribute('minify.dest_path', args[0].to_s)
+         }],
+
+        ['Jekyll::Minify::Minifier', :private, :minify_with_fallback, 'minify.file_process',
+         lambda { |span, _this, args, _result|
+           span.set_attribute('minify.file_path', args[0].to_s)
+           span.set_attribute('minify.asset_type', args[1].to_s)
+         }],
+
+        ['Jekyll::Minify::Minifier', :private, :minify_html, 'minify.html_minify',
+         lambda { |span, _this, args, result|
+           span.set_attribute('minify.input_size_bytes', args[0].bytesize)
+           span.set_attribute('minify.output_size_bytes', result.to_s.bytesize)
+         }],
+
+        ['Jekyll::Minify::Minifier', :private, :minify_css, 'minify.css_minify',
+         lambda { |span, _this, args, result|
+           span.set_attribute('minify.input_size_bytes', args[0].bytesize)
+           span.set_attribute('minify.output_size_bytes', result.to_s.bytesize)
+         }],
+
+        ['Jekyll::Minify::Minifier', :private, :minify_js, 'minify.js_minify',
+         lambda { |span, _this, args, result|
+           span.set_attribute('minify.input_size_bytes', args[0].bytesize)
+           span.set_attribute('minify.output_size_bytes', result.to_s.bytesize)
+         }]
+      ].freeze
+      # :nocov:
+
+      # Returns the active OTel tracer, or a no-op tracer if opentelemetry-api is absent.
+      #
+      # @return [OpenTelemetry::Trace::Tracer, NoopTracer]
+      def self.tracer
+        @tracer ||=
+          if defined?(OpenTelemetry)
+            # :nocov:
+            OpenTelemetry.tracer_provider.tracer(TRACER_NAME, Jekyll::Minify::VERSION)
+            # :nocov:
+          else
+            NoopTracer.new
+          end
+      end
+
+      # Wraps a block in an OTel span.
+      #
+      # @param span_name [String] Dot-separated span name (e.g. 'minify.html_minify')
+      # @param attributes [Hash] Initial span attributes
+      # @yieldparam span [OpenTelemetry::Trace::Span, NoopSpan] Active span
+      # @return [Object] The return value of the block
+      def self.instrument(span_name, attributes: {}, &block)
+        tracer.in_span(span_name, attributes: attributes, &block)
+      end
+
+      # Resets the cached tracer and installation flag. Call in tests after changing OTel configuration.
+      #
+      # @return [void]
+      def self.reset!
+        @tracer    = nil
+        @installed = false
+      end
+
+      # Returns true when OTel is requested via standard environment variables.
+      #
+      # install! guards on this so the prepend wrappers are only applied when
+      # a real exporter is configured. In CI and local tests (no OTel env vars)
+      # business logic classes are untouched, keeping allow_any_instance_of stubs
+      # and other RSpec mechanics fully functional.
+      #
+      # @return [Boolean]
+      def self.enabled?
+        ENV.key?('OTEL_EXPORTER_OTLP_ENDPOINT') || ENV.key?('OTEL_SERVICE_NAME')
+      end
+
+      # Installs wrappers on all classes listed in TRACED_METHODS using Module#prepend.
+      #
+      # Called once at plugin load time (end of jekyll-minify.rb, after all requires),
+      # but only when enabled? returns true. Use OTEL_EXPORTER_OTLP_ENDPOINT or
+      # OTEL_SERVICE_NAME to activate tracing.
+      #
+      # @return [void]
+      def self.install!
+        return if @installed
+
+        @installed = true
+        setup_sdk!
+        TRACED_METHODS.group_by { |e| e[0] }.each do |class_name, entries|
+          prepend_wrappers(resolve_class(class_name), entries)
+        end
+      end
+
+      # Configures the OTel SDK from standard env vars if the SDK gem is available.
+      # Silently no-ops when opentelemetry-sdk or opentelemetry-exporter-otlp is
+      # not installed. Uses SimpleSpanProcessor (not the SDK default
+      # BatchSpanProcessor) since Jekyll is a short-lived CLI process that could
+      # exit before a batch timer fires, dropping spans.
+      #
+      # jekyll-theme-centos loads several instrumented plugins in one process;
+      # OpenTelemetry::SDK.configure overwrites the global tracer_provider on
+      # every call, so only the first plugin to reach here (see
+      # sdk_already_configured?) configures the SDK — later callers reuse that
+      # provider. The at_exit/post_write hooks are registered once, by whichever
+      # plugin wins, and flush every plugin's spans, not just this one's.
+      #
+      # @return [void]
+      def self.setup_sdk!
+        return if sdk_already_configured?
+
+        # :nocov:
+        require 'opentelemetry/sdk'
+        require 'opentelemetry/exporter/otlp'
+        exporter  = OpenTelemetry::Exporter::OTLP::Exporter.new
+        processor = OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(exporter)
+        OpenTelemetry::SDK.configure { |c| c.add_span_processor(processor) }
+
+        at_exit { OpenTelemetry.tracer_provider&.shutdown }
+        Jekyll::Hooks.register(:site, :post_write, priority: 0) { OpenTelemetry.tracer_provider&.force_flush }
+      rescue LoadError
+        nil
+        # :nocov:
+      end
+
+      # True when some plugin (this one or another) already installed a real
+      # SDK-backed tracer_provider, in which case setup_sdk! must not run again.
+      #
+      # @return [Boolean]
+      def self.sdk_already_configured?
+        defined?(OpenTelemetry::SDK::Trace::TracerProvider) &&
+          OpenTelemetry.tracer_provider.is_a?(OpenTelemetry::SDK::Trace::TracerProvider)
+      end
+
+      # Resolves a dot-separated class name to a constant; returns nil on NameError.
+      #
+      # @param name [String] fully-qualified class name, e.g. 'Jekyll::Minify::Minifier'
+      # @return [Class, nil]
+      def self.resolve_class(name)
+        name.split('::').reduce(Object) { |m, c| m.const_get(c) }
+      rescue NameError
+        nil
+      end
+
+      # Applies instance and class-method wrappers to klass; skips if klass is nil.
+      #
+      # @param klass [Class, nil] the class to wrap
+      # @param entries [Array<Array>] TRACED_METHODS rows scoped to klass
+      # @return [void]
+      def self.prepend_wrappers(klass, entries)
+        return unless klass
+
+        class_entries, instance_entries = entries.partition { |e| e[1] == :class }
+        klass.prepend(build_wrapper_module(instance_entries)) unless instance_entries.empty?
+        klass.singleton_class.prepend(build_wrapper_module(class_entries)) unless class_entries.empty?
+      end
+
+      # Builds an anonymous module that wraps each listed method in a span.
+      #
+      # @param entries [Array<Array>] TRACED_METHODS rows to wrap
+      # @return [Module] anonymous module ready to be prepended
+      def self.build_wrapper_module(entries)
+        Module.new do
+          entries.each { |entry| Instrumentation.send(:define_traced_method, self, entry) }
+        end
+      end
+
+      # Defines a single span-wrapped method on mod for one TRACED_METHODS entry.
+      #
+      # @param mod [Module] the wrapper module being built
+      # @param entry [Array] one TRACED_METHODS row: [class_name, method_type, method_name, span_name, attr_proc]
+      # @return [void]
+      def self.define_traced_method(mod, entry)
+        _class_name, method_type, method_name, span_name, attr_proc = entry
+        mod.define_method(method_name) do |*args, **kwargs, &blk|
+          Instrumentation.send(:run_traced, span_name, attr_proc, self, args) { super(*args, **kwargs, &blk) }
+        end
+        mod.send(:private, method_name) if method_type == :private
+      end
+
+      # Runs the original method inside a span, applying attr_proc on success and
+      # recording exceptions on the span before re-raising them.
+      #
+      # @param span_name [String] span name
+      # @param attr_proc [Proc, nil] attribute callback: ->(span, receiver, args, result)
+      # @param receiver [Object] the wrapped method's receiver (self)
+      # @param args [Array] positional arguments passed to the wrapped method
+      # @yieldreturn [Object] the original (unwrapped) method's return value
+      # @return [Object] the wrapped method's return value
+      def self.run_traced(span_name, attr_proc, receiver, args)
+        instrument(span_name) do |span|
+          result = yield
+          attr_proc&.call(span, receiver, args, result)
+          result
+        rescue StandardError => e
+          span.record_exception(e)
+          raise
+        end
+      end
+
+      private_class_method :build_wrapper_module, :define_traced_method, :run_traced, :prepend_wrappers, :setup_sdk!,
+                           :sdk_already_configured?
+
+      # No-op tracer used when opentelemetry-api is not loaded.
+      class NoopTracer
+        # Yields a NoopSpan and returns the block's value.
+        #
+        # @param _name [String] span name (ignored)
+        # @param _opts [Hash] span options (ignored)
+        # @yieldparam span [NoopSpan]
+        # @return [Object] the block's return value
+        def in_span(_name, **_opts)
+          yield NoopSpan.new
+        end
+      end
+
+      # No-op span that silently accepts all attribute and event calls.
+      class NoopSpan
+        # No-op attribute setter. Accepts and ignores any arguments.
+        #
+        # @return [NoopSpan] self
+        def set_attribute(*)
+          self
+        end
+
+        # No-op exception recorder. Accepts and ignores any arguments.
+        #
+        # @return [NoopSpan] self
+        def record_exception(*)
+          self
+        end
+
+        # No-op status setter. Accepts and ignores any arguments.
+        #
+        # @return [void]
+        def status=(*); end
+      end
+    end
+  end
+end

data/lib/jekyll-minify/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Minify
+    # The version of the jekyll-minify gem.
+    #
+    # Updated with each release to reflect the current version. Independent of the
+    # gemspec's CI-generated version; used to identify this library's version to
+    # the OpenTelemetry tracer provider.
+    VERSION = '1.0.6'
+  end
+end

data/lib/jekyll-minify.rb

@@ -76,6 +76,9 @@ rescue LoadError
                                         'Install with: gem install minify_html'
 end
 
+require_relative 'jekyll-minify/version'
+require_relative 'jekyll-minify/instrumentation'
+
 module Jekyll
   # Jekyll plugin for automatic minification of HTML, CSS, and JavaScript.
   module Minify
@@ -146,7 +149,7 @@ module Jekyll
       # Returns immediately if with_minify is false or the destination directory does not exist.
       #
       # @param site [Jekyll::Site] the Jekyll site object providing dest and config
-      # @return [void]
+      # @return [Hash, nil] the run's @stats, or nil if minification was skipped
       def run(site)
         unless plugin_enabled?(site.config)
           Jekyll.logger.info 'jekyll-minify:', 'Minification disabled (with_minify: false).'
@@ -162,6 +165,7 @@ module Jekyll
 
         minify_each_file(dest)
         log_statistics
+        @stats
       end
 
       private
@@ -486,3 +490,5 @@ end
 Jekyll::Hooks.register :site, :post_write, priority: :low do |site|
   Jekyll::Minify::Minifier.minify_site(site)
 end
+
+Jekyll::Minify::Instrumentation.install! if Jekyll::Minify::Instrumentation.enabled?

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-minify
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.1.0
 platform: ruby
 authors:
-- ReleaseBot
+- Alain Reguera Delgado
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -43,6 +43,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -171,7 +185,7 @@ dependencies:
         version: '0.9'
 description: Jekyll plugin to minify HTML, CSS, and JavaScript files.
 email:
-- group_58921183_bot_c5520aeba366578e2e444dd181ff3e23@noreply.gitlab.com
+- alain.reguera@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -179,6 +193,8 @@ files:
 - LICENSE
 - README.md
 - lib/jekyll-minify.rb
+- lib/jekyll-minify/instrumentation.rb
+- lib/jekyll-minify/version.rb
 homepage: https://gitlab.com/CentOS/artwork/centos-web/jekyll-minify
 licenses:
 - MIT