sponsored_logs 0.2.0 → 0.3.1

data/lib/sponsored_logs/banner.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module SponsoredLogs
+  # Premium box-drawn ad inventory: the multi-line :banner placement. Turns a
+  # single ad line into above-the-fold, framed real estate in your stdout.
+  #
+  module Banner
+    # Body width, in columns, of a banner placement.
+    #
+    WIDTH = 60
+
+    # Glyph sets per impact tier + ascii_only fallback, ordered
+    # [top-left, top-right, bottom-left, bottom-right, horizontal, vertical].
+    #
+    GLYPHS = {
+      light: %w[┌ ┐ └ ┘ ─ │],
+      heavy: %w[┏ ┓ ┗ ┛ ━ ┃],
+      double: %w[╔ ╗ ╚ ╝ ═ ║],
+      ascii: %w[+ + + + - |]
+    }.freeze
+
+    # Draw the frame for one ad. ascii_only overrides whatever impact tier was
+    # purchased with the plain +/-/| fallback set. Inner span matches
+    # "<vert> <60 cols> <vert>" so every corner and edge lines up.
+    #
+    def self.render(entry, prefix, ascii_only, color: false)
+      top, top_r, bot, bot_r, horiz, vert = GLYPHS[ascii_only ? :ascii : (entry[:box] || :light)]
+      span = WIDTH + 2
+
+      body = wrap_text(entry[:text].to_s, WIDTH).map do |line|
+        "#{vert} #{line.ljust(WIDTH)} #{vert}"
+      end
+
+      corners = [top, top_r, horiz]
+      [top_border(prefix, corners, span, color: color), *body, "#{bot}#{horiz * span}#{bot_r}"].join("\n")
+    end
+
+    # Top border with the prefix embedded as "<h> [AD] <h-fill>". A blank
+    # prefix collapses to a solid rule (no gap, no tag). The fill math is
+    # computed against the PLAIN prefix, then the gilded tag is swapped in --
+    # ANSI escapes are zero-width, so gilding must not shift the border count.
+    # corners is [top-left, top-right, horizontal].
+    #
+    def self.top_border(prefix, corners, span, color: false)
+      corner, corner_r, horiz = corners
+      return "#{corner}#{horiz * span}#{corner_r}" if prefix.empty?
+
+      tag = " #{prefix} "
+      fill = horiz * (span - 1 - tag.length)
+      gilded = " #{Color.colorize(prefix, enabled: color)} "
+      "#{corner}#{horiz}#{gilded}#{fill}#{corner_r}"
+    end
+
+    # Word-wrap text to width columns, breaking a single word longer than the
+    # width mid-word. Always returns at least one (possibly blank) line.
+    #
+    def self.wrap_text(text, width)
+      lines = []
+      current = +""
+
+      text.to_s.split(/\s+/).each do |word|
+        word = word.dup
+        while word.length > width
+          lines << current unless current.empty?
+          current = +""
+          lines << word[0, width]
+          word = word[width..]
+        end
+
+        candidate = current.empty? ? word : "#{current} #{word}"
+        if candidate.length > width
+          lines << current
+          current = word
+        else
+          current = candidate
+        end
+      end
+
+      lines << current
+      lines.reject!(&:empty?)
+      lines.empty? ? [""] : lines
+    end
+  end
+end

data/lib/sponsored_logs/color.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SponsoredLogs
+  # The gilding layer: wraps the [AD] prefix in 256-color gold so premium
+  # inventory reads as premium in a live terminal. Zero-width escapes only --
+  # the visible column count is unchanged, so nothing that measures the plain
+  # text (border fill, alignment) has to know color happened.
+  #
+  module Color
+    # SGR 256-color gold (xterm 214) open, plus the universal reset. Matches the
+    # gold accent in docs/banner.svg -- the AD tag is always the money color.
+    #
+    GOLD = "\e[38;5;214m"
+    RESET = "\e[0m"
+
+    require "logger"
+
+    # Gild text in gold when enabled, otherwise hand it back untouched so the
+    # non-TTY path stays byte-identical to the classic plain line.
+    #
+    def self.colorize(text, enabled:)
+      return text unless enabled
+
+      "#{GOLD}#{text}#{RESET}"
+    end
+
+    # Decide whether an emission to target should be gilded. :never never
+    # gilds; :always always gilds (overriding NO_COLOR); :auto gilds only when
+    # NO_COLOR is unset AND the target is a real TTY. A Logger's sink is treated
+    # as non-TTY (log files/streams must never get ANSI), so it gilds only under
+    # :always.
+    #
+    def self.gild?(target, mode:, env: ENV)
+      case mode
+      when :never then false
+      when :always then true
+      else no_color_unset?(env) && tty?(target)
+      end
+    end
+
+    # NO_COLOR convention (https://no-color.org): any non-empty value disables
+    # color. Unset or empty leaves auto-gilding available.
+    #
+    def self.no_color_unset?(env)
+      value = env["NO_COLOR"]
+      value.nil? || value.empty?
+    end
+
+    # A target is a TTY only when it is an IO that reports tty?. Loggers report
+    # false here on purpose -- we never unwrap the buried logdev.
+    #
+    def self.tty?(target)
+      return false if target.is_a?(Logger)
+
+      target.respond_to?(:tty?) && target.tty?
+    end
+  end
+end

data/lib/sponsored_logs/configuration.rb

@@ -2,12 +2,20 @@
 
 module SponsoredLogs
   class Configuration
-    attr_accessor :probability, :periodic, :interval, :output, :ad_prefix, :ads, :selection, :store, :report_page
+    attr_accessor :probability, :periodic, :interval, :output, :ad_prefix, :ads, :selection, :store, :report_page,
+                  :ascii_only, :house_ads
+    attr_reader :color
+
+    # Gilding modes for the [AD] prefix. :auto gilds only on a NO_COLOR-clear
+    # TTY; :always forces gold (overriding NO_COLOR); :never stays plain.
+    #
+    COLOR_MODES = %i[auto always never].freeze
 
     # Settings that map 1:1 onto an accessor. ads/ads_file are handled
     # separately because they interact (ads wins; ads_file loads into ads).
     #
-    DIRECT_KEYS = %i[probability periodic interval output ad_prefix selection store report_page].freeze
+    DIRECT_KEYS = %i[probability periodic interval output ad_prefix selection store report_page ascii_only
+                     house_ads color].freeze
     KNOWN_KEYS = (DIRECT_KEYS + %i[ads ads_file]).freeze
 
     def initialize
@@ -20,6 +28,17 @@ module SponsoredLogs
       @selection = :weight
       @store = Ledger::Store::Memory.new
       @report_page = false
+      @ascii_only = false
+      @house_ads = true
+      @color = :auto
+    end
+
+    # Coerce any unrecognized gilding mode back to :auto so a stray value never
+    # forces or suppresses color unexpectedly.
+    #
+    def color=(value)
+      symbol = value.to_s.strip.downcase.to_sym
+      @color = COLOR_MODES.include?(symbol) ? symbol : :auto
     end
 
     # Apply a hash of settings. Symbol or string keys are accepted; unknown

data/lib/sponsored_logs/env.rb

@@ -8,15 +8,34 @@ module SponsoredLogs
       truthy?(env["SPONSORED_LOGS"])
     end
 
+    # Maps each SPONSORED_LOGS_* variable to its option key and a coercer. Only
+    # variables actually present are applied, so the manual sponsor! path is
+    # untouched. Add a new override by extending this table.
+    #
+    OPTION_MAP = {
+      "SPONSORED_LOGS_PROBABILITY" => [:probability, ->(v) { Float(v) }],
+      "SPONSORED_LOGS_INTERVAL" => [:interval, ->(v) { Float(v) }],
+      "SPONSORED_LOGS_PERIODIC" => [:periodic, ->(v) { truthy?(v) }],
+      "SPONSORED_LOGS_PREFIX" => [:ad_prefix, ->(v) { v }],
+      "SPONSORED_LOGS_ADS_FILE" => [:ads_file, ->(v) { v }],
+      "SPONSORED_LOGS_SELECTION" => [:selection, :to_sym.to_proc],
+      "SPONSORED_LOGS_ASCII_ONLY" => [:ascii_only, ->(v) { truthy?(v) }],
+      "SPONSORED_LOGS_HOUSE_ADS" => [:house_ads, ->(v) { truthy?(v) }],
+      "SPONSORED_LOGS_COLOR" => [:color, ->(v) { color_mode(v) }]
+    }.freeze
+
+    # Map a raw SPONSORED_LOGS_COLOR value to a gilding mode symbol, falling
+    # back to :auto for anything unrecognized (invalid never forces color).
+    #
+    def self.color_mode(value)
+      symbol = value.to_s.strip.downcase.to_sym
+      Configuration::COLOR_MODES.include?(symbol) ? symbol : :auto
+    end
+
     def self.options(env = ENV)
-      opts = {}
-      opts[:probability] = Float(env["SPONSORED_LOGS_PROBABILITY"]) if env["SPONSORED_LOGS_PROBABILITY"]
-      opts[:interval]    = Float(env["SPONSORED_LOGS_INTERVAL"])    if env["SPONSORED_LOGS_INTERVAL"]
-      opts[:periodic]    = truthy?(env["SPONSORED_LOGS_PERIODIC"])  if env["SPONSORED_LOGS_PERIODIC"]
-      opts[:ad_prefix]   = env["SPONSORED_LOGS_PREFIX"]             if env["SPONSORED_LOGS_PREFIX"]
-      opts[:ads_file]    = env["SPONSORED_LOGS_ADS_FILE"]           if env["SPONSORED_LOGS_ADS_FILE"]
-      opts[:selection]   = env["SPONSORED_LOGS_SELECTION"].to_sym   if env["SPONSORED_LOGS_SELECTION"]
-      opts
+      OPTION_MAP.each_with_object({}) do |(var, (key, coerce)), opts|
+        opts[key] = coerce.call(env[var]) if env[var]
+      end
     end
 
     def self.truthy?(value)

data/lib/sponsored_logs/flight.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "time"
+
+module SponsoredLogs
+  # Flight-window and impression-cap predicates for a normalized ad. Extracted
+  # from Advertisers so the eligibility rules live in one cohesive place and the
+  # host module stays under Metrics/ModuleLength. Advertisers keeps thin
+  # delegators for its public surface (live?, status, capped?, eligible?).
+  #
+  module Flight
+    # Whether `now` falls before an ad's flight window opens. A nil starts_at is
+    # open-ended, so the ad has always started.
+    #
+    def self.before_start?(ad, now)
+      !ad[:starts_at].nil? && now < ad[:starts_at]
+    end
+
+    # Whether `now` falls after an ad's flight window closes. A nil ends_at is
+    # open-ended, so the ad never ends.
+    #
+    def self.after_end?(ad, now)
+      !ad[:ends_at].nil? && now > ad[:ends_at]
+    end
+
+    # Whether an ad is within its flight window at `now`. Missing bounds are
+    # open-ended (nil starts_at = always started; nil ends_at = never ends).
+    #
+    def self.live?(ad, now)
+      !before_start?(ad, now) && !after_end?(ad, now)
+    end
+
+    # Whether an ad has reached its impression cap given a current count.
+    # Uncapped ads (nil cap) are never capped.
+    #
+    def self.capped?(ad, count)
+      cap = ad[:cap]
+      return false if cap.nil?
+
+      count.to_i >= cap
+    end
+
+    # Whether an ad is eligible for selection: live at `now` and not capped.
+    #
+    def self.eligible?(ad, now, count)
+      live?(ad, now) && !capped?(ad, count)
+    end
+
+    # Status of an ad at `now` given its impression count: :exhausted (cap
+    # reached), :scheduled (window not started), :ended (window passed),
+    # :evergreen (no bounds), or :active.
+    #
+    def self.status(ad, now = Time.now, count = 0)
+      return :exhausted if capped?(ad, count)
+      return :scheduled if before_start?(ad, now)
+      return :ended if after_end?(ad, now)
+      return :evergreen if ad[:starts_at].nil? && ad[:ends_at].nil?
+
+      :active
+    end
+  end
+end

data/lib/sponsored_logs/report/app/helpers/sponsored_logs/reports_helper.rb

@@ -13,13 +13,7 @@ module SponsoredLogs
       exhausted: "#f59e0b"
     }.freeze
 
-    BAR_HEIGHT = 22
-    BAR_GAP = 10
-    LABEL_WIDTH = 320
-    TRACK_WIDTH = 360
-    VALUE_PAD = 8
-
-    # Segment palette for the share-of-spend donut, drawn from the banner
+    # Segment palette for the donut charts, drawn from the banner
     # (gold, cyan, greens, violets) and cycled for larger pools.
     #
     DONUT_COLORS = %w[
@@ -27,50 +21,30 @@ module SponsoredLogs
       #34d399 #60a5fa #f472b6 #fb923c #22d3ee
     ].freeze
 
-    # Render a horizontal bar chart as inline SVG from report ad rows.
-    # `value` picks the numeric field per row; `format` renders the label.
-    #
-    def bar_chart(ads, value:, format:)
-      rows = ads.map { |ad| [ad[:text], value.call(ad).to_f] }
-                .sort_by { |(_text, v)| -v }
-      return content_tag(:p, "No data yet.", class: "empty") if rows.empty?
-
-      max = rows.map { |(_t, v)| v }.max
-      max = 1.0 if max <= 0
-
-      height = rows.size * (BAR_HEIGHT + BAR_GAP)
-      width = LABEL_WIDTH + TRACK_WIDTH + 90
-
-      bars = rows.each_with_index.map do |(text, v), i|
-        y = i * (BAR_HEIGHT + BAR_GAP)
-        bar_w = ((v / max) * TRACK_WIDTH).round(2)
-        svg_bar(text, format.call(v), y, bar_w)
-      end.join
+    DONUT_TOP_N = 7
 
-      content_tag(
-        :svg,
-        raw(bars),
-        xmlns: "http://www.w3.org/2000/svg",
-        viewBox: "0 0 #{width} #{height}",
-        role: "img",
-        class: "chart",
-        style: "width:100%;max-width:#{width}px;height:auto;"
-      )
-    end
-
-    # Share-of-spend donut as inline SVG. Each ad becomes an arc sized by its
-    # fraction of total spend, rendered as an offset stroke on a circle, with a
-    # legend beside it. Ads with zero spend are omitted.
+    # Donut chart as inline SVG. Each row becomes an arc sized by its fraction
+    # of the total, with a legend beside it. Zero/negative values are omitted;
+    # only the top DONUT_TOP_N slices are shown individually and the remainder
+    # is rolled into a single "Other" slice so the ring still totals 100%.
+    #
+    # `label` picks the slice name, `value` the number to slice on (default
+    # spend), `format` renders the legend value (default dollars), and `empty`
+    # is the message when there's nothing to show.
     #
-    def donut_chart(ads)
-      rows = ads.map { |ad| [ad[:text], ad[:spend].to_f] }
-                .select { |(_t, v)| v.positive? }
-                .sort_by { |(_t, v)| -v }
+    def donut_chart(rows_in, label: ->(row) { row[:text] },
+                    value: ->(row) { row[:spend] },
+                    format: ->(v) { "$#{Kernel.format("%.2f", v)}" },
+                    empty: "No data yet.")
+      rows = rows_in.map { |row| [label.call(row), value.call(row).to_f] }
+                    .select { |(_t, v)| v.positive? }
+                    .sort_by { |(_t, v)| -v }
+      return content_tag(:p, empty, class: "empty") if rows.empty?
+
+      rows = collapse_to_top(rows, DONUT_TOP_N)
       total = rows.sum { |(_t, v)| v }
-      return content_tag(:p, "No spend yet.", class: "empty") if total <= 0
-
       radius = 60
-      donut_svg(donut_segments(rows, total, radius), donut_legend(rows, total), radius)
+      donut_svg(donut_segments(rows, total, radius), donut_legend(rows, total, format), radius)
     end
 
     # Delivery-to-goal bars for capped ads across all groups: a filled track
@@ -89,6 +63,24 @@ module SponsoredLogs
       content_tag(:div, raw(rows), class: "cap-list")
     end
 
+    # Per-advertiser rollup table (advertiser accounts), sorted by spend.
+    # Returns nil for an empty set so the caller can skip the section.
+    #
+    def advertiser_table(rows)
+      return if rows.nil? || rows.empty?
+
+      header = content_tag(:thead, content_tag(:tr,
+                                               safe_join([
+                                                           content_tag(:th, "Advertiser"),
+                                                           content_tag(:th, "Ads", class: "num"),
+                                                           content_tag(:th, "Impressions", class: "num"),
+                                                           content_tag(:th, "Spend", class: "num")
+                                                         ])))
+
+      body = content_tag(:tbody, safe_join(rows.map { |a| advertiser_row(a) }))
+      content_tag(:table, safe_join([header, body]))
+    end
+
     # Colored pill for an ad's flight status (:active/:scheduled/:ended/:evergreen).
     #
     def status_badge(status)
@@ -116,6 +108,7 @@ module SponsoredLogs
 
       header = content_tag(:thead, content_tag(:tr,
                                                safe_join([
+                                                           content_tag(:th, "Advertiser"),
                                                            content_tag(:th, "Creative"),
                                                            content_tag(:th, "Status"),
                                                            content_tag(:th, "Flight"),
@@ -135,6 +128,7 @@ module SponsoredLogs
 
     def campaign_row(ad)
       content_tag(:tr, safe_join([
+                                   content_tag(:td, ad[:advertiser], class: "advertiser"),
                                    content_tag(:td, ad[:text]),
                                    content_tag(:td, status_badge(ad[:status])),
                                    content_tag(:td, flight_window(ad[:starts_at], ad[:ends_at]), class: "flight"),
@@ -144,6 +138,15 @@ module SponsoredLogs
                                  ]))
     end
 
+    def advertiser_row(account)
+      content_tag(:tr, safe_join([
+                                   content_tag(:td, account[:advertiser], class: "advertiser"),
+                                   content_tag(:td, account[:ads], class: "num"),
+                                   content_tag(:td, account[:impressions], class: "num"),
+                                   content_tag(:td, "$#{format("%.2f", account[:spend])}", class: "num")
+                                 ]))
+    end
+
     def donut_segments(rows, total, radius)
       circumference = 2 * Math::PI * radius
       offset = 0.0
@@ -156,9 +159,20 @@ module SponsoredLogs
       end.join
     end
 
-    def donut_legend(rows, total)
+    # Keep the top n rows; fold the rest into a single "Other" slice so the
+    # donut still represents the whole.
+    #
+    def collapse_to_top(rows, count)
+      return rows if rows.size <= count
+
+      top = rows.first(count)
+      other = rows.drop(count).sum { |(_t, v)| v }
+      top + [["Other", other]]
+    end
+
+    def donut_legend(rows, total, format)
       rows.each_with_index.map do |(text, v), i|
-        donut_legend_row(text, v, v / total, DONUT_COLORS[i % DONUT_COLORS.size])
+        donut_legend_row(text, v, v / total, DONUT_COLORS[i % DONUT_COLORS.size], format)
       end.join
     end
 
@@ -175,12 +189,12 @@ module SponsoredLogs
           stroke-dashoffset="#{dash_offset}"/>)
     end
 
-    def donut_legend_row(text, spend, frac, color)
+    def donut_legend_row(text, value, frac, color, format)
       pct = (frac * 100).round(1)
       %(<div class="legend-row">
           <span class="legend-swatch" style="background:#{color};"></span>
           <span class="legend-label">#{esc(truncate_label(text))}</span>
-          <span class="legend-value">$#{format("%.2f", spend)} &middot; #{pct}%</span>
+          <span class="legend-value">#{esc(format.call(value))} &middot; #{pct}%</span>
         </div>)
     end
 
@@ -218,19 +232,6 @@ module SponsoredLogs
         </div>)
     end
 
-    def svg_bar(label, value_label, y, bar_w)
-      text_y = y + (BAR_HEIGHT / 2) + 4
-      label_text = esc(truncate_label(label))
-      value_text = esc(value_label)
-
-      %(
-        <text x="0" y="#{text_y}" class="bar-label">#{label_text}</text>
-        <rect x="#{LABEL_WIDTH}" y="#{y}" width="#{TRACK_WIDTH}" height="#{BAR_HEIGHT}" class="bar-track"/>
-        <rect x="#{LABEL_WIDTH}" y="#{y}" width="#{bar_w}" height="#{BAR_HEIGHT}" class="bar-fill"/>
-        <text x="#{LABEL_WIDTH + bar_w + VALUE_PAD}" y="#{text_y}" class="bar-value">#{value_text}</text>
-      )
-    end
-
     # Truncate the raw text first, then escape, so we never slice through an
     # HTML entity.
     #

data/lib/sponsored_logs/report/app/views/sponsored_logs/reports/show.html.erb

@@ -61,7 +61,10 @@
     .totals .label { display: block; font-size: 0.66rem; text-transform: uppercase;
                      letter-spacing: 0.09em; color: var(--muted); font-family: var(--mono); }
     .totals .value { font-size: 1.9rem; font-weight: 800; font-family: var(--mono);
-                     color: var(--gold-1); margin-top: 0.35rem; }
+                     margin-top: 0.35rem;
+                     background: linear-gradient(90deg, var(--gold-0), var(--gold-1));
+                     -webkit-background-clip: text; background-clip: text;
+                     -webkit-text-fill-color: transparent; color: var(--gold-1); }
 
     h2 { font-size: 0.78rem; text-transform: uppercase; letter-spacing: 0.09em;
          color: var(--cyan); font-family: var(--mono); margin: 2.25rem 0 0.75rem; }
@@ -80,18 +83,12 @@
     .empty { color: var(--faint); font-style: italic; margin-top: 1.5rem;
              font-family: var(--mono); }
 
-    .chart { display: block; }
-    .chart .bar-label { font-size: 12px; fill: var(--muted); font-family: var(--mono); }
-    .chart .bar-value { font-size: 12px; fill: var(--gold-1); font-variant-numeric: tabular-nums;
-                        font-family: var(--mono); }
-    .chart .bar-track { fill: #0f1727; rx: 4; }
-    .chart .bar-fill { fill: url(#slGold); rx: 4; }
-
     .badge { display: inline-block; padding: 0.15rem 0.55rem; border-radius: 999px;
              color: #0b0f19; font-size: 0.62rem; text-transform: uppercase;
              letter-spacing: 0.04em; font-weight: 800; font-family: var(--mono); }
     td.flight { font-variant-numeric: tabular-nums; color: var(--muted);
                 white-space: nowrap; font-family: var(--mono); font-size: 0.8rem; }
+    td.advertiser { font-weight: 700; color: var(--gold-1); white-space: nowrap; }
 
     /* Share-of-spend donut */
     .donut-wrap { display: flex; align-items: center; gap: 1.5rem; flex-wrap: wrap;
@@ -122,16 +119,6 @@
   </style>
 </head>
 <body>
-  <!-- Shared gradient for SVG bar fills, matching the banner's gold. -->
-  <svg width="0" height="0" style="position:absolute" aria-hidden="true">
-    <defs>
-      <linearGradient id="slGold" x1="0%" y1="0%" x2="100%" y2="0%">
-        <stop offset="0%" stop-color="#f59e0b" />
-        <stop offset="100%" stop-color="#fbbf24" />
-      </linearGradient>
-    </defs>
-  </svg>
-
   <div class="wrap">
     <header class="masthead">
       <span class="dots"><i class="r"></i><i class="y"></i><i class="g"></i></span>
@@ -153,17 +140,23 @@
     </div>
   </div>
 
+  <% if @report[:advertisers].any? %>
+    <h2>Advertiser accounts</h2>
+    <%= advertiser_table(@report[:advertisers]) %>
+  <% end %>
+
   <% if @report[:ads].empty? %>
     <p class="empty">No impressions delivered yet.</p>
   <% else %>
     <h2>Share of spend</h2>
-    <%= donut_chart(@report[:ads]) %>
-
-    <h2>Spend by advertiser</h2>
-    <%= bar_chart(@report[:ads], value: ->(ad) { ad[:spend] }, format: ->(v) { "$#{format('%.2f', v)}" }) %>
-
-    <h2>Impressions by advertiser</h2>
-    <%= bar_chart(@report[:ads], value: ->(ad) { ad[:impressions] }, format: ->(v) { v.to_i.to_s }) %>
+    <%= donut_chart(@report[:advertisers], label: ->(a) { a[:advertiser] },
+                                           empty: "No spend yet.") %>
+
+    <h2>Share of impressions</h2>
+    <%= donut_chart(@report[:advertisers], label: ->(a) { a[:advertiser] },
+                                           value: ->(a) { a[:impressions] },
+                                           format: ->(v) { v.to_i.to_s },
+                                           empty: "No impressions yet.") %>
 
     <h2>Running campaigns</h2>
     <%= campaign_table(@report[:ads]) %>

data/lib/sponsored_logs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SponsoredLogs
-  VERSION = "0.2.0"
+  VERSION = "0.3.1"
 end

data/lib/sponsored_logs.rb

@@ -3,7 +3,10 @@
 require "logger"
 
 require_relative "sponsored_logs/version"
+require_relative "sponsored_logs/color"
 require_relative "sponsored_logs/advertisers"
+require_relative "sponsored_logs/flight"
+require_relative "sponsored_logs/banner"
 require_relative "sponsored_logs/ads_file"
 require_relative "sponsored_logs/ledger/store/base"
 require_relative "sponsored_logs/ledger/store/memory"
@@ -76,7 +79,11 @@ module SponsoredLogs
       return if ad.nil?
 
       ledger.record(ad)
-      line = Advertisers.render(ad, configuration.ad_prefix)
+      line = Advertisers.render(
+        ad, configuration.ad_prefix,
+        ascii_only: configuration.ascii_only,
+        color: Color.gild?(target, mode: configuration.color)
+      )
 
       if target.is_a?(Logger)
         # Raw << avoids re-triggering our own Logger#add patch (infinite loop).
@@ -120,7 +127,8 @@ module SponsoredLogs
         spend: ledger.total_spend.round(2),
         ads: grouped[:running],
         upcoming: grouped[:upcoming],
-        finished: grouped[:finished]
+        finished: grouped[:finished],
+        advertisers: advertiser_rollup(grouped)
       }
     end
 
@@ -189,6 +197,7 @@ module SponsoredLogs
     #
     def report_row(text, meta, entry, status)
       {
+        advertiser: meta[:advertiser] || Advertisers::DEFAULT_ADVERTISER,
         text: text,
         impressions: entry ? entry.impressions : 0,
         cpm: entry ? entry.cpm : meta[:cpm].to_f,
@@ -200,6 +209,22 @@ module SponsoredLogs
       }
     end
 
+    # Roll every report row up to its advertiser: total impressions, spend, and
+    # ad count per advertiser account, sorted by spend descending.
+    #
+    def advertiser_rollup(grouped)
+      by_advertiser = grouped.values.flatten.group_by { |row| row[:advertiser] }
+      accounts = by_advertiser.map do |advertiser, ads|
+        {
+          advertiser: advertiser,
+          ads: ads.size,
+          impressions: ads.sum { |a| a[:impressions] },
+          spend: ads.sum { |a| a[:spend] }.round(2)
+        }
+      end
+      accounts.sort_by { |a| -a[:spend] }
+    end
+
     def start_periodic_thread
       stop_periodic_thread
       @periodic_thread = Thread.new do