catpm 0.9.6 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3731353688fdebaef1f9cb164731daba00a0d69df65da03dc309f6f7901e2708
-  data.tar.gz: 4ef7e26d0b721c8fea556f797d74c58ef2b0df8f9257edead653393fcb991229
+  metadata.gz: '0283e922a2169d04e59405a273250c1fd226b4b72731f01ba6f6495b6a216ce2'
+  data.tar.gz: 5af58e9875ee9ce18afc02816e79d94cb025025218b78695e560a7a662ce2953
 SHA512:
-  metadata.gz: df633940cf6beba3252b6915c45d22688ff23ef3200edf17622e971ce65191ad85af476bfdd853a2bee449da6d28df81431c48e663001c80b14242ba407d3a7b
-  data.tar.gz: 473011238fdf84d011bf9d3c0ceed1d47b7f1a3be5e6e9d640f6f66b62273c2a396c425166b09ceb5b0b8bf63a993e51651d99d373c48b1058ead4ede2451266
+  metadata.gz: 0e73b3ea6819f8633104be971da72ad30c5de1b13bc4e0bece856d1e13b5987c705fb322f48c91622ae87d8acbd6b3d71ff0d2bb151939370a2685f4cf0ec7a7
+  data.tar.gz: 988f46467fbf05398f71cefff884584fb1daf2b148500df100b0824049d2cc659e5e74038e65c8de30cec27b36aaa6d503c5267475b8b4c7313e35b4e208e375

data/README.md

@@ -1,5 +1,5 @@
 gem build catpm.gemspec
-gem push catpm-0.9.5.gem
+gem push catpm-0.9.7.gem
 
 # Catpm
 

data/app/controllers/catpm/application_controller.rb

@@ -3,16 +3,28 @@
 module Catpm
   class ApplicationController < ActionController::Base
     before_action :authenticate!
+    rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
+
+    def not_found
+      render 'catpm/shared/not_found', layout: 'catpm/application', status: :not_found
+    end
 
     private
 
+    def render_not_found
+      respond_to do |format|
+        format.html { render 'catpm/shared/record_not_found', layout: 'catpm/application', status: :not_found }
+        format.json { render json: { error: 'not_found' }, status: :not_found }
+      end
+    end
+
     def authenticate!
       if Catpm.config.access_policy
         unless Catpm.config.access_policy.call(request)
-          render plain: "Unauthorized", status: :unauthorized
+          render plain: 'Unauthorized', status: :unauthorized
         end
       elsif Catpm.config.http_basic_auth_user.present? && Catpm.config.http_basic_auth_password.present?
-        authenticate_or_request_with_http_basic("Catpm") do |username, password|
+        authenticate_or_request_with_http_basic('Catpm') do |username, password|
           ActiveSupport::SecurityUtils.secure_compare(username, Catpm.config.http_basic_auth_user) &
             ActiveSupport::SecurityUtils.secure_compare(password, Catpm.config.http_basic_auth_password)
         end

data/app/views/catpm/shared/not_found.html.erb

@@ -0,0 +1,24 @@
+<% content_for :head_extra do %>
+<style>
+  body { display: flex; flex-direction: column; min-height: 100vh; }
+  .not-found-content { flex: 1; display: flex; align-items: center; justify-content: center; }
+  .not-found-inner { text-align: center; padding: 24px; }
+  .not-found-cat {
+    font-family: var(--font-mono); font-size: 14px; line-height: 1.3;
+    color: var(--accent); white-space: pre; margin-bottom: 20px; user-select: none;
+  }
+  .not-found-code { font-size: 13px; color: var(--text-2); font-weight: 500; letter-spacing: 1px; margin-bottom: 24px; }
+  .not-found-link { font-size: 13px; color: var(--accent); }
+  .not-found-link:hover { text-decoration: underline; }
+</style>
+<% end %>
+
+<div class="not-found-content">
+  <div class="not-found-inner">
+    <div class="not-found-cat"> /\_/\
+( o.o )
+ > ^ <</div>
+    <div class="not-found-code">404</div>
+    <a href="<%= catpm.status_index_path %>" class="not-found-link">&larr; Dashboard</a>
+  </div>
+</div>

data/app/views/catpm/shared/record_not_found.html.erb

@@ -0,0 +1,24 @@
+<% content_for :head_extra do %>
+<style>
+  body { display: flex; flex-direction: column; min-height: 100vh; }
+  .not-found-content { flex: 1; display: flex; align-items: center; justify-content: center; }
+  .not-found-inner { text-align: center; padding: 24px; }
+  .not-found-paws { font-size: 40px; color: var(--accent); margin-bottom: 20px; letter-spacing: 6px; }
+  .not-found-title { font-size: 15px; font-weight: 600; color: var(--text-0); margin-bottom: 6px; }
+  .not-found-hint { font-size: 13px; color: var(--text-2); max-width: 380px; margin: 0 auto 24px; line-height: 1.6; }
+  .not-found-link { font-size: 13px; color: var(--accent); }
+  .not-found-link:hover { text-decoration: underline; }
+</style>
+<% end %>
+
+<div class="not-found-content">
+  <div class="not-found-inner">
+    <div class="not-found-paws">&#x1F43E;</div>
+    <div class="not-found-title">This record is no longer available</div>
+    <p class="not-found-hint">
+      catpm rotates older performance data to keep memory usage low.
+      This resource was likely purged during a routine cleanup.
+    </p>
+    <a href="<%= catpm.status_index_path %>" class="not-found-link">&larr; Dashboard</a>
+  </div>
+</div>

data/config/routes.rb

@@ -29,4 +29,5 @@ Catpm::Engine.routes.draw do
       patch :toggle_pin
     end
   end
+  match '*unmatched', to: 'application#not_found', via: :all
 end

data/lib/catpm/collector.rb

@@ -6,11 +6,9 @@ module Catpm
     MIN_GAP_MS = 1.0
     DEFAULT_ERROR_STATUS = 500
     DEFAULT_SUCCESS_STATUS = 200
-    # Cap global force-instrument counter to avoid cascade when many requests
-    # are slow. Without this cap, apps with 30% slow requests would see ~23%
-    # instrumentation instead of the configured 1/random_sample_rate.
-    MAX_FORCE_INSTRUMENT_COUNT = 3
-    FORCE_INSTRUMENT_MAX_ENDPOINTS = 100 # cap per-endpoint force-instrument hash
+
+    @instrumentation_mutex = Mutex.new
+    @active_instrumented_count = 0
 
     class << self
       def process_action_controller(event)
@@ -63,25 +61,6 @@ module Catpm
           instrumented: instrumented
         )
 
-        # Force the NEXT HTTP request to be fully instrumented when this one
-        # wasn't instrumented and was slow/error.
-        # Filling phase is handled by @http_filling_active flag in
-        # should_instrument_request? — no need for force_instrument here.
-        if !instrumented
-          if payload[:exception] || duration >= Catpm.config.slow_threshold_for(:http)
-            trigger_force_instrument
-          elsif !@http_filling_active
-            # Detect new/underfilled endpoints that appeared after filling phase ended
-            max = Catpm.config.max_random_samples_per_endpoint
-            if max
-              endpoint_key = ['http', target, operation]
-              if instrumented_sample_counts[endpoint_key] < max
-                @http_filling_active = true
-              end
-            end
-          end
-        end
-
         if sample_type
           context = build_http_context(payload)
 
@@ -286,11 +265,6 @@ module Catpm
           instrumented: instrumented
         )
 
-        # Slow spike detection: force instrument next request for this endpoint
-        if !instrumented && (error || duration >= Catpm.config.slow_threshold_for(kind.to_sym))
-          trigger_force_instrument(kind: kind, target: target, operation: operation)
-        end
-
         if sample_type
           context = (context || {}).dup
 
@@ -417,152 +391,49 @@ module Catpm
 
       # --- Pre-sampling: decide BEFORE request whether to instrument ---
 
-      # Eagerly load sample counts at startup so old endpoints don't
-      # re-enter filling phase on every process restart.
-      # Called from Lifecycle.register_hooks after flusher init.
-      def load_sample_counts_eagerly!
-        @instrumented_sample_counts = load_sample_counts_from_db
-        @instrumented_sample_counts_loaded = true
-        recompute_http_filling_active
-      end
-
       # For HTTP middleware where endpoint is unknown at start.
-      # Returns true if this request should get full instrumentation.
       def should_instrument_request?
-        # Force after slow spike detection
-        if (@force_instrument_count || 0) > 0
-          @force_instrument_count -= 1
-          return true
-        end
-
-        # During filling phase, instrument all requests so underfilled
-        # endpoints collect their quota (max_random_samples_per_endpoint).
-        # The flag is set by load_sample_counts_eagerly! and maintained
-        # by early_sample_type as endpoints fill up.
-        return true if @http_filling_active
-
-        rand(Catpm.config.random_sample_rate) == 0
+        rand(Catpm.config.random_sample_rate) == 0 && try_start_instrumentation
       end
 
       # For track_request where endpoint is known at start.
-      # Filling phase ensures new endpoints get instrumented samples quickly.
-      def should_instrument?(kind, target, operation)
-        endpoint_key = [kind.to_s, target.to_s, (operation || '').to_s]
-
-        # Force after slow spike
-        if force_instrument_endpoints.delete(endpoint_key)
-          return true
-        end
-
-        # Filling phase — endpoint hasn't collected enough instrumented samples yet
-        max = Catpm.config.max_random_samples_per_endpoint
-        if max.nil? || instrumented_sample_counts[endpoint_key] < max
-          return true
-        end
-
-        rand(Catpm.config.random_sample_rate) == 0
-      end
-
-      # Called when a slow/error request had no instrumentation —
-      # forces the NEXT request(s) to be fully instrumented.
-      #
-      # Two modes (mutually exclusive to avoid double-instrumentation):
-      # - With endpoint: sets per-endpoint flag consumed by should_instrument?
-      #   (for track_request paths where endpoint is known)
-      # - Without endpoint: increments global counter consumed by
-      #   should_instrument_request? (for middleware path where endpoint is unknown)
-      def trigger_force_instrument(kind: nil, target: nil, operation: nil)
-        if kind && target
-          endpoint_key = [kind.to_s, target.to_s, (operation || '').to_s]
-          if force_instrument_endpoints.size < FORCE_INSTRUMENT_MAX_ENDPOINTS
-            force_instrument_endpoints[endpoint_key] = true
-          end
+      # Always instruments targets matched by always_sample_targets.
+      def should_instrument?(_kind, target, _operation)
+        if Catpm.config.always_sample?(target)
+          try_start_instrumentation
         else
-          @force_instrument_count = [(@force_instrument_count || 0) + 1, MAX_FORCE_INSTRUMENT_COUNT].min
+          rand(Catpm.config.random_sample_rate) == 0 && try_start_instrumentation
         end
       end
 
-      def reset_sample_counts!
-        @instrumented_sample_counts = nil
-        @instrumented_sample_counts_loaded = false
-        @force_instrument_endpoints = nil
-        @force_instrument_count = nil
-        @http_filling_active = false
+      # Reset the concurrency counter (for tests and config reloads).
+      def reset_instrumentation_counter!
+        @instrumentation_mutex.synchronize { @active_instrumented_count = 0 }
       end
 
-      private
-
-      # Recompute whether any HTTP endpoint is still below its sample quota.
-      # Called after loading counts from DB and when an endpoint exits filling.
-      def recompute_http_filling_active
-        max = Catpm.config.max_random_samples_per_endpoint
-        @http_filling_active = if max
-          # True if hash is empty (new app / new endpoints may appear) or any endpoint below quota
-          instrumented_sample_counts.empty? || instrumented_sample_counts.any? { |_, c| c < max }
-        else
-          false # unlimited quota → no filling phase for HTTP middleware
+      # Release an instrumentation slot. Must be called in ensure block
+      # for every request where try_start_instrumentation returned true.
+      def end_instrumentation
+        @instrumentation_mutex.synchronize do
+          @active_instrumented_count = [@active_instrumented_count - 1, 0].max
         end
       end
 
-      # Evict half the entries from instrumented_sample_counts.
-      # Prefers evicting filled entries (count >= max) to avoid
-      # re-triggering filling phase for those endpoints.
-      def evict_sample_counts(max_random)
-        evict_count = instrumented_sample_counts.size / 2
-        if max_random
-          filled_keys = []
-          unfilled_keys = []
-          instrumented_sample_counts.each do |k, c|
-            (c >= max_random ? filled_keys : unfilled_keys) << k
-          end
-          # Evict filled first (safe), then unfilled if needed
-          to_evict = (filled_keys + unfilled_keys).first(evict_count)
-          to_evict.each { |k| instrumented_sample_counts.delete(k) }
-        else
-          evict_count.times { instrumented_sample_counts.shift }
-        end
-      end
-
-      def force_instrument_endpoints
-        @force_instrument_endpoints ||= {}
-      end
+      # Atomically claim an instrumentation slot if within budget.
+      # Returns true if the slot was acquired, false if at capacity.
+      # Already-running instrumented requests are not affected.
+      def try_start_instrumentation
+        @instrumentation_mutex.synchronize do
+          max = Catpm.config.effective_max_concurrent_instrumented
+          return false if @active_instrumented_count >= max
 
-      def instrumented_sample_counts
-        return @instrumented_sample_counts if @instrumented_sample_counts_loaded
-
-        @instrumented_sample_counts = load_sample_counts_from_db
-        @instrumented_sample_counts_loaded = true
-        @instrumented_sample_counts
-      end
-
-      # Pre-populate filling counters from DB so old endpoints don't
-      # re-enter filling phase on every process restart.
-      # Temporarily clears thread-local to prevent our query from being
-      # captured as a segment in any active request.
-      def load_sample_counts_from_db
-        counts = Hash.new(0)
-        return counts unless defined?(Catpm::Sample) && Catpm::Bucket.table_exists?
-
-        saved_rs = Thread.current[:catpm_request_segments]
-        Thread.current[:catpm_request_segments] = nil
-        begin
-          Catpm::Sample.joins(:bucket)
-            .where(sample_type: 'random')
-            .group('catpm_buckets.kind', 'catpm_buckets.target', 'catpm_buckets.operation')
-            .count
-            .each do |(kind, target, operation), count|
-              counts[[kind.to_s, target.to_s, operation.to_s]] = count
-            end
-        ensure
-          Thread.current[:catpm_request_segments] = saved_rs
+          @active_instrumented_count += 1
+          true
         end
-
-        counts
-      rescue => e
-        Catpm.config.error_handler&.call(e)
-        Hash.new(0)
       end
 
+      private
+
       # Remove near-zero-duration "code" spans that merely wrap a "controller" span.
       # This happens when CallTracer (TracePoint) captures a thin dispatch method
       # (e.g. Telegram::WebhookController#process) whose :return fires before the
@@ -618,49 +489,12 @@ module Catpm
 
       # Determine sample type at event creation time so only sampled events
       # carry full context in the buffer.
-      #
-      # Non-instrumented requests never get a sample (they have no segments).
-      # Filling phase is handled by the caller via trigger_force_instrument,
-      # so the NEXT request gets full instrumentation with segments.
-      #
-      # Post-filling: non-instrumented requests just contribute duration/count
-      # to the bucket, no sample created.
+      # Non-instrumented requests have no segments — skip sample creation.
       def early_sample_type(error:, duration:, kind:, target:, operation:, instrumented: true)
-        # Errors: only create sample for instrumented requests (with segments).
-        # Non-instrumented errors are still tracked in error_groups via
-        # event.error? — occurrence counts, contexts, and backtrace are preserved.
-        # trigger_force_instrument ensures the next occurrence gets full segments.
-        return 'error' if error && instrumented
-
-        is_slow = duration >= Catpm.config.slow_threshold_for(kind.to_sym)
-
-        # Non-instrumented requests have no segments — skip sample creation.
-        # Slow/error spikes are handled by the caller via trigger_force_instrument
-        # so the NEXT request gets full instrumentation with useful segments.
-        return nil unless instrumented
-
-        # Count this instrumented request towards filling phase completion.
-        # Both slow and random requests count — without this, endpoints where
-        # most requests exceed slow_threshold would never exit the filling phase,
-        # causing 100% instrumentation regardless of random_sample_rate.
-        endpoint_key = [kind.to_s, target, operation.to_s]
-        count = instrumented_sample_counts[endpoint_key]
-        max_random = Catpm.config.max_random_samples_per_endpoint
-        if max_random.nil? || count < max_random
-          # Evict when hash exceeds derived limit — prefer filled entries
-          max_entries = Catpm.config.effective_sample_counts_max
-          if instrumented_sample_counts.size >= max_entries
-            evict_sample_counts(max_random)
-          end
-          instrumented_sample_counts[endpoint_key] = count + 1
-
-          # Endpoint just reached quota — recheck if any filling endpoints remain
-          if max_random && count + 1 >= max_random
-            recompute_http_filling_active
-          end
-        end
-
-        return 'slow' if is_slow
+        always = Catpm.config.always_sample?(target)
+        return 'error' if error && (instrumented || always)
+        return nil unless instrumented || always
+        return 'slow' if duration >= Catpm.config.slow_threshold_for(kind.to_sym)
 
         'random'
       end

data/lib/catpm/configuration.rb

@@ -9,8 +9,12 @@ module Catpm
     BUFFER_MEMORY_SHARE = 0.5       # 50% of max_memory for event buffer
     CACHE_ENTRIES_PER_MB = 10_000   # ~100 bytes/entry in path_cache
     PATH_CACHE_BUDGET_SHARE = 0.05  # 5% of max_memory for path_cache
-    SAMPLE_COUNTS_PER_MB = 12_500   # ~80 bytes/entry in sample counts hash
-    SAMPLE_COUNTS_BUDGET_SHARE = 0.02 # 2% of max_memory for sample counts
+    INSTRUMENTATION_BUDGET_SHARE = 0.30  # 30% of max_memory for concurrent instrumented requests
+
+    # Estimated per-request memory for instrumentation budget
+    ESTIMATED_BYTES_PER_STACK_SAMPLE = 10_000  # ~10 KB: backtrace_locations array (~100 frames × ~100 bytes)
+    ESTIMATED_BYTES_PER_SEGMENT = 500          # segment hash with strings
+    DEFAULT_SEGMENTS_ESTIMATE = 200            # used when max_segments_per_request is nil
 
     # Boolean / non-numeric settings — plain attr_accessor
     attr_accessor :enabled,
@@ -32,7 +36,8 @@ module Catpm
                   :events_enabled,
                   :track_own_requests,
                   :downsampling_thresholds,
-                  :show_untracked_segments
+                  :show_untracked_segments,
+                  :always_sample_targets
 
     # Numeric settings that must be positive numbers (nil not allowed)
     REQUIRED_NUMERIC = %i[
@@ -124,6 +129,7 @@ module Catpm
       @caller_scan_depth = 50
       @instrument_call_tree = false
       @show_untracked_segments = false
+      @always_sample_targets = []
     end
 
     # Buffer gets BUFFER_MEMORY_SHARE of max_memory, scaled by thread count
@@ -137,9 +143,13 @@ module Catpm
       (max_memory * CACHE_ENTRIES_PER_MB * PATH_CACHE_BUDGET_SHARE).to_i
     end
 
-    # Sample counts hash limit derived from max_memory
-    def effective_sample_counts_max
-      (max_memory * SAMPLE_COUNTS_PER_MB * SAMPLE_COUNTS_BUDGET_SHARE).to_i
+    # Max concurrent instrumented requests derived from max_memory.
+    # Each instrumented request holds stack samples + segments in memory
+    # until the request completes. This limits how many can run at once
+    # so total live instrumentation data stays within budget.
+    def effective_max_concurrent_instrumented
+      budget_bytes = max_memory * 1_048_576 * INSTRUMENTATION_BUDGET_SHARE
+      (budget_bytes / estimated_instrumented_request_bytes).clamp(1, 1000).to_i
     end
 
     def slow_threshold_for(kind)
@@ -147,7 +157,17 @@ module Catpm
     end
 
     def ignored?(target)
-      ignored_targets.any? do |pattern|
+      match_target?(ignored_targets, target)
+    end
+
+    def always_sample?(target)
+      match_target?(always_sample_targets, target)
+    end
+
+    private
+
+    def match_target?(patterns, target)
+      patterns.any? do |pattern|
         case pattern
         when Regexp then pattern.match?(target)
         when String
@@ -159,5 +179,19 @@ module Catpm
         end
       end
     end
+
+    def estimated_instrumented_request_bytes
+      bytes = 0
+
+      if instrument_stack_sampler || instrument_call_tree
+        samples = max_stack_samples_per_request || StackSampler::HARD_SAMPLE_CAP
+        bytes += samples * ESTIMATED_BYTES_PER_STACK_SAMPLE
+      end
+
+      segments = max_segments_per_request || DEFAULT_SEGMENTS_ESTIMATE
+      bytes += segments * ESTIMATED_BYTES_PER_SEGMENT
+
+      [bytes, 50_000].max # minimum 50 KB estimate per request
+    end
   end
 end

data/lib/catpm/flusher.rb

@@ -346,7 +346,6 @@ module Catpm
       @last_cleanup_at = Time.now
       downsample_buckets
       cleanup_expired_data if Catpm.config.retention_period
-      Collector.reset_sample_counts!
     end
 
     def downsample_buckets

data/lib/catpm/lifecycle.rb

@@ -8,7 +8,6 @@ module Catpm
 
         initialize_buffer
         initialize_flusher
-        load_sample_counts
         apply_patches
 
         # Start the flusher in the current process.
@@ -25,12 +24,6 @@ module Catpm
 
       private
 
-      def load_sample_counts
-        Collector.load_sample_counts_eagerly!
-      rescue => e
-        Catpm.config.error_handler&.call(e)
-      end
-
       def apply_patches
         if Catpm.config.instrument_net_http
           if defined?(::Net::HTTP)

data/lib/catpm/middleware.rb

@@ -33,6 +33,7 @@ module Catpm
     ensure
       req_segments&.stop_sampler
       req_segments&.release!
+      Collector.end_instrumentation if req_segments
       Thread.current[:catpm_request_segments] = nil
       Thread.current[:catpm_request_start] = nil
       Thread.current[:catpm_tracked_instrumented] = nil

data/lib/catpm/trace.rb

@@ -75,14 +75,15 @@ module Catpm
   #     process_update(...)
   #   end
   #
-  def self.track_request(kind: :http, target:, operation: '', context: {}, metadata: {})
+  def self.track_request(kind: :http, target:, operation: '', context: {}, metadata: {}, always_sample: false)
     return yield unless enabled?
 
     req_segments = Thread.current[:catpm_request_segments]
     owns_segments = false
 
     if req_segments.nil? && config.instrument_segments
-      if Collector.should_instrument?(kind, target, operation)
+      force = always_sample || config.always_sample?(target)
+      if force ? Collector.try_start_instrumentation : Collector.should_instrument?(kind, target, operation)
         use_sampler = config.instrument_stack_sampler || config.instrument_call_tree
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         req_segments = RequestSegments.new(
@@ -122,11 +123,11 @@ module Catpm
 
       if owns_segments
         req_segments&.release!
+        Collector.end_instrumentation
         Thread.current[:catpm_request_segments] = nil
         # Mark that this request was already instrumented and processed by
         # track_request. Without this, process_action_controller would see
-        # nil req_segments and falsely trigger force_instrument for slow
-        # requests — even though they were fully instrumented here.
+        # nil req_segments and think the request was not instrumented.
         Thread.current[:catpm_tracked_instrumented] = true
       end
     end

data/lib/catpm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Catpm
-  VERSION = '0.9.6'
+  VERSION = '0.10.0'
 end

data/lib/catpm.rb

@@ -39,7 +39,7 @@ module Catpm
       @buffer = nil
       @flusher = nil
       Fingerprint.reset_caches!
-      Collector.reset_sample_counts!
+      Collector.reset_instrumentation_counter!
     end
 
     def enabled?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: catpm
 version: !ruby/object:Gem::Version
-  version: 0.9.6
+  version: 0.10.0
 platform: ruby
 authors:
 - ''
@@ -66,6 +66,8 @@ files:
 - app/views/catpm/samples/show.html.erb
 - app/views/catpm/shared/_page_nav.html.erb
 - app/views/catpm/shared/_segments_waterfall.html.erb
+- app/views/catpm/shared/not_found.html.erb
+- app/views/catpm/shared/record_not_found.html.erb
 - app/views/catpm/status/index.html.erb
 - app/views/catpm/system/index.html.erb
 - app/views/catpm/system/pipeline.html.erb