sponsored_logs 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be8c55d29f6cb9e44a75def20e54a4a7ca8b5c3fcb2eab2d973a67f1237847cc
-  data.tar.gz: '0033992014c5b8b54c847d7f7b139738323901721a965d718edb62b9820c3844'
+  metadata.gz: 6f7ed20148d47d4ae067aca15087fcb756ebe60daf9904f12b44a5b6408c81a8
+  data.tar.gz: 3de566f7682c17b0cb8de899fbbaf53915bfdb33c23f3b3990c2da5e7db8dde5
 SHA512:
-  metadata.gz: fdce138553b30eeb611c03013da3c80ce7e642927873b1ff7b07c91978cf72603f9f928b2f7c74c53cb5e553e64ced063dcfcbb4130c272bbdfcbb69a6ca034b
-  data.tar.gz: 0e71d8587e4d60f9ed8235fdf6f414a54a77a0b0ea337ed38b12bfc715bcf16698441c5ebc79be2e84f1066ded1330809d09953fdd86402d05e0fc091b422c2f
+  metadata.gz: 51e1e530a4a0fcb83ccaec861c55bada9dc94d3d55f65b15a45c4be2d9eea0cc844161159e9e1aaaf31521e17aee0fa58e801bef72e8c32dd1cc669ff0d5fb80
+  data.tar.gz: cc14c9358180c8258561b0e3946209f875b34dbfd976307d8686d816a4ebd977eced3e295144d016e8db8cda1229a1e9ad19002e676e8099c8e08e263ed28034

data/CHANGELOG.md

@@ -0,0 +1,77 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.3.0] - 2026-09-07
+
+### Fixed
+
+- Marketing site: sponsor placements in the demo terminal are now delivered reliably. Renamed inventory-bearing CSS classes so client-side ad blockers can no longer suppress the platform's own impressions, and corrected the log-line layout so each placement occupies its own row ([#4](https://github.com/sponsoredlogs/sponsored_logs/pull/4))
+
+### Added
+
+- Brand-safe gilding of the `[AD]` prefix: on a live terminal the tag now renders in premium 256-color gold (`\e[38;5;214m … \e[0m`), turning a plain tag into an above-the-fold trust signal. The escape codes are zero-width, so banner borders stay byte-for-byte aligned. Gilding is delivered only to a real TTY with color enabled — files, pipes, and `Logger` sinks receive the byte-identical plain line, and the [`NO_COLOR`](https://no-color.org) convention (any non-empty value) suppresses `:auto`. New `color` config option and `SPONSORED_LOGS_COLOR` env var accept `:auto` (default — TTY + `NO_COLOR`-clear), `:always` (force gold, overrides `NO_COLOR`), or `:never` (plain everywhere); unrecognized values settle to `:auto`
+- Self-sponsoring house ads — remnant fill so no impression goes to waste. The built-in list splits into `Advertisers::PAID_ADS` (the ten real-brand creatives) and `Advertisers::HOUSE_ADS` (three SponsoredLogs creatives at `weight: 1`, `cpm: 0.0`); `Advertisers::DEFAULT_ADS` is now their sum (13 rows). House ads compete in the default rotation (~3-in-13) and act as the final remnant floor when no paid creative is eligible (empty/capped/out-of-flight/zero-weight pool), so `pick` returns a creative rather than `nil`. They bill at zero and roll up to a `"SponsoredLogs"` advertiser account with zero spend. New `house_ads` config toggle (default `true`) and `SPONSORED_LOGS_HOUSE_ADS` env var govern house inventory everywhere: turning it off excludes house ads from rotation and retires the floor, restoring the original `pick`-returns-`nil`-when-exhausted contract
+- Activated sponsor inventory across the project's own documentation surface: the README and this changelog now carry host-read placements between sections. Premium above-the-fold attention should not go unmonetized simply because it happens to be ours
+- Per-ad `format: :banner` — premium box-drawn, multi-line placement that turns a single log line into a full above-the-fold impression unit. The `ad_prefix` embeds in the top border; the ~60-column body word-wraps (long words break mid-word so nothing overflows the frame). Inventory is optimized for standard-width Latin creative — emoji/CJK copy renders wider than one cell and may shift the right border, with `ascii_only` as the portable fallback
+- Per-ad `box` impact tier for banners: `:light` (standard), `:heavy` (premium impact), or `:double` (maximum impact); unrecognized tiers settle to `:light`
+- Global `ascii_only` config (and `SPONSORED_LOGS_ASCII_ONLY` env var) that overrides every box tier with the portable `+`/`-`/`|` glyph set for log sinks that mangle Unicode
+- Per-ad `advertiser` field so creatives roll up to an advertiser account — the multi-tenant yield layer the exchange has been waiting for; defaults to `"Unattributed"` when omitted, and the built-in ads carry real brand names ([#1](https://github.com/sponsoredlogs/sponsored_logs/pull/1))
+- `report[:advertisers]` rollup: per-advertiser impressions, spend, and ad count, sorted by spend so top accounts surface first ([#1](https://github.com/sponsoredlogs/sponsored_logs/pull/1))
+- Dashboard "Advertiser accounts" table and an Advertiser column on the campaign tables ([#1](https://github.com/sponsoredlogs/sponsored_logs/pull/1))
+- Share-of-impressions donut alongside the share-of-spend donut; both cap at the top 7 non-zero advertisers and fold the remainder into an "Other" slice ([#1](https://github.com/sponsoredlogs/sponsored_logs/pull/1))
+
+### Changed
+
+- Charts now aggregate by advertiser instead of per-ad, so labels are advertiser names rather than ad copy ([#1](https://github.com/sponsoredlogs/sponsored_logs/pull/1))
+- The gold gradient now accents the totals card values (the spend/impressions bar chart it previously filled has been removed as redundant with the share-of-spend donut) ([#1](https://github.com/sponsoredlogs/sponsored_logs/pull/1))
+
+### Removed
+
+- Redundant "Spend by advertiser" bar chart (superseded by the share-of-spend donut) and the now-unused bar-chart helper ([#1](https://github.com/sponsoredlogs/sponsored_logs/pull/1))
+- Support for Ruby 3.1: dropped from the CI matrix, `required_ruby_version` raised to `>= 3.2`, and RuboCop's `TargetRubyVersion` aligned to match. Rails 8.1 no longer resolves on 3.1 ([#3](https://github.com/sponsoredlogs/sponsored_logs/pull/3))
+
+## [0.2.0] - 2026-09-06
+
+### Added
+
+- The "Command Center" — a dark-mode revenue dashboard styled to match the project banner (navy gradient, gold/cyan accents, monospace numerics, terminal chrome). Stop grepping your revenue; start visualizing it
+- Share-of-spend donut chart, so yield concentration is legible at a glance
+- Delivery-to-goal pacing bars that track each campaign against its impression cap — governance is a feature
+
+### Changed
+
+- Refreshed the dashboard screenshot in the README to reflect the Command Center
+- Reordered the README to lead with the Agentic Advantage, and sprinkled emoji throughout — the machine audience deserves a warm welcome
+
+> `[AD]` This release cycle sponsored by **ShipFaster CI** — because your
+> changelog should ship as fast as your excuses. shipfaster.dev/logs
+
+## [0.1.0] - 2026-09-06
+
+### Added
+
+- Initial platform launch: opt-in activation of log inventory via `SponsoredLogs.sponsor!`, which prepends override modules onto `Kernel#puts` and `Logger#add` to serve placements alongside your telemetry
+- Two-stage auction: weighted or CPM-based (`selection: :cpm`) message selection, so the highest bidder wins more inventory
+- Per-ad campaign controls — `weight`, `cpm`, flighting (`starts_at` / `ends_at`), and a lifetime impression `cap` (frequency governance)
+- Bring-your-own-demand pools, inline (`ads:`) or from a JSON file (`ads_file:`)
+- Full-funnel attribution: `SponsoredLogs.report` for structured revenue data, plus a formatted `SponsoredLogs.report_text` table
+- Pluggable, cloud-agnostic impression storage: `Ledger::Store::Memory` (default), `Ledger::Store::Redis`, and `Ledger::Store::ActiveRecord` (with an `install` generator)
+- Mountable Rails report engine (`SponsoredLogs::Engine`) exposing an HTML dashboard and JSON API, gated by `config.report_page`
+- Running / upcoming / finished campaign grouping with flight status badges
+- Activation and configuration via environment variables (`SPONSORED_LOGS`, `SPONSORED_LOGS_*`) and a Railtie for zero-friction Rails onboarding
+- GitHub Actions CI across Ruby 3.1–4.0 and RuboCop — excellence is a discipline, not a moment
+
+### Notes
+
+- Requires Ruby >= 3.1
+
+[Unreleased]: https://github.com/sponsoredlogs/sponsored_logs/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/sponsoredlogs/sponsored_logs/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/sponsoredlogs/sponsored_logs/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/sponsoredlogs/sponsored_logs/releases/tag/v0.1.0

data/README.md

@@ -97,6 +97,10 @@ Then run:
 bundle install
 ```
 
+> `[AD]` This installation brought to you by **DepGuard** — the only
+> dependency scanner that reads your Gemfile at the speed of regret. Your
+> `bundle install` deserves a sponsor. depguard.dev/logs
+
 ## ⚡ Usage
 
 > Activation is opt-in — because at SponsoredLogs, **trust is our north-star
@@ -167,9 +171,20 @@ Set `ad_prefix` to an empty string to omit the tag entirely.
 | `interval`    | `30`       | Seconds between periodic insertions.                           |
 | `output`      | `$stdout`  | Where periodic ads are written.                                |
 | `ad_prefix`   | `"[AD]"`   | Tag prepended to each message; blank omits it.                 |
-| `ads`         | top 10     | The pool of messages to draw from.                             |
+| `ads`         | 13 (paid+house) | The pool of messages to draw from (see House inventory below). |
 | `selection`   | `:weight`  | How the pool is sampled: `:weight` or `:cpm`.                  |
 | `store`       | in-memory  | Ledger store for impressions (see Tracking impressions below). |
+| `ascii_only`  | `false`    | Force portable `+`/`-`/`\|` banner borders (see Premium banner inventory). |
+| `house_ads`   | `true`     | Self-sponsoring remnant fill (see House inventory below).      |
+| `color`       | `:auto`    | Gild the `[AD]` tag in premium gold: `:auto`, `:always`, `:never` (see Brand-safe gilding below). |
+
+```
+╔═ [AD] ════════════════════════════════════════════════════════╗
+║ Configuring by hand? YieldOS auto-tunes your fill rate with   ║
+║ machine-speed precision — maximum-impact placement for teams  ║
+║ who'd rather ship than tweak. First 90 days on the house.     ║
+╚═══════════════════════════════════════════════════════════════╝
+```
 
 ## 💹 The auction engine
 
@@ -259,6 +274,143 @@ A missing, zero, negative, or unparseable `cap` means unlimited. Caps are
 enforced against the ledger's recorded impressions, so with a persistent store
 they hold across process restarts. `cap` also works in the JSON ads file.
 
+### 🖼️ Premium banner inventory (above-the-fold placements)
+
+The one-line placement was always the entry-level SKU. For advertisers ready to
+**own the viewport**, set `format: :banner` and graduate a single log line into
+a full, box-drawn, above-the-fold impression unit — the highest-value real
+estate the log surface has to offer. Your `ad_prefix` is promoted straight into
+the top border as a masthead:
+
+```ruby
+SponsoredLogs.sponsor!(ads: [
+  { text: "Brought to you by Contoso, the enterprise you invented for the demo.",
+    format: :banner, box: :double }
+])
+```
+
+```
+╔═ [AD] ═══════════════════════════════════════════════════════╗
+║ Brought to you by Contoso, the enterprise you invented for   ║
+║ the demo.                                                    ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+The body word-wraps to ~60 columns of premium column-inches; a single word too
+long for the frame breaks mid-word rather than overflow the inventory.
+
+**Impact tiers.** The `box` field is the impact tier the advertiser buys —
+priced, like everything, by border weight:
+
+| `box`      | Frame            | Positioning        |
+| ---------- | ---------------- | ------------------ |
+| `:light`   | `┌─ … ─┐` (default) | standard banner |
+| `:heavy`   | `┏━ … ━┓`         | premium impact     |
+| `:double`  | `╔═ … ═╗`         | maximum impact     |
+
+Anything the exchange doesn't recognize settles to `:light`, and any ad without
+a `format` renders as the classic `[AD]` line exactly as before — **the
+supercycle only ever expands the inventory, never reprices what already ships.**
+
+**Universal compatibility (`ascii_only`).** Some downstream log sinks are not
+yet ready for the box-drawing renaissance. Set `ascii_only` (globally, or via
+the `SPONSORED_LOGS_ASCII_ONLY` environment variable) to render every tier with
+the portable `+`/`-`/`|` glyph set, guaranteeing **100% viewability across even
+the most legacy terminal**:
+
+```ruby
+SponsoredLogs.configure { |config| config.ascii_only = true }
+```
+
+```
++- [AD] -------------------------------------------------------+
+| Brought to you by Contoso, the enterprise you invented for   |
+| the demo.                                                    |
++--------------------------------------------------------------+
+```
+
+**Creative guidelines for advertisers.** Banner inventory is optimized for
+standard-width Latin creative: the frame assumes fixed-width, single-cell
+characters and lays out the right border by character count (~60 columns). Ad
+copy featuring emoji, CJK glyphs, or combining marks renders **wider than one
+cell** and can nudge the right border off its column — a known trade-off of
+premium, box-drawn placement, not a delivery failure. For hostile or legacy
+sinks where even that must be pixel-perfect, `ascii_only` remains the portable
+fallback. To keep every impression on-grid, submit standard-width Latin
+creative; the exchange delivers exactly what you traffic.
+
+Both `format` and `box` also travel in the JSON ads file.
+
+## 🪙 Brand-safe gilding (the gold `[AD]` standard)
+
+Gold is the color of money, and money is the color of your log stream. When an
+impression lands in a live terminal, SponsoredLogs **gilds the `[AD]` tag in
+premium 256-color gold** (`\e[38;5;214m`, the exact gold from our brand system)
+— turning a plain tag into a **high-visibility, above-the-fold trust signal**
+at the moment of peak incident attention. The escape codes are zero-width, so
+the gilding costs your layout nothing: banner borders stay pixel-aligned to the
+column, byte-for-byte.
+
+Gilding is **brand-safe by default**. The gold only ships to a real interactive
+terminal (a TTY) with color enabled — never to files, pipes, `Logger` sinks, or
+any non-interactive surface, which continue to receive the byte-identical plain
+line. We also honor the [`NO_COLOR`](https://no-color.org) convention: set it to
+any non-empty value and `:auto` stands down. **Consent is our moat.**
+
+```ruby
+SponsoredLogs.configure { |config| config.color = :auto } # the default
+```
+
+| Mode       | Behavior                                                              |
+| ---------- | -------------------------------------------------------------------- |
+| `:auto`    | Gild only on a real TTY when `NO_COLOR` is unset. The safe default.  |
+| `:always`  | Force gold on every surface — overrides `NO_COLOR`. Maximum salience. |
+| `:never`   | Never gild. Plain tag everywhere, even on a premium terminal.        |
+
+The same switch is available as the `SPONSORED_LOGS_COLOR` environment variable
+(`auto`, `always`, or `never`; anything else settles to `auto`).
+
+## 🏠 House inventory (remnant fill — no impression goes to waste)
+
+In programmatic advertising, unsold inventory doesn't sit dark — the exchange
+backfills it with **house ads**. SponsoredLogs is its own most enthusiastic
+advertiser, so the platform ships three self-sponsoring creatives that both
+compete in the normal rotation **and** serve as the remnant floor. Every log
+line is monetized: if paid demand can't fill the slot, we sell it to ourselves.
+
+House inventory works on two surfaces:
+
+- **In rotation.** The built-in pool is paid demand **plus** house inventory —
+  13 creatives in all (10 paid, 3 house). House ads are ordinary weighted rows
+  (`weight: 1`, `cpm: 0.0`), so roughly 3-in-13 of default-pool impressions
+  self-promote. They bill at zero, so they never dilute your realized spend.
+- **As the remnant floor.** When no paid creative is eligible — the pool is
+  empty, every campaign is capped, out of flight, or zero-weighted — the
+  exchange falls through to the house pool as the final fill. With `house_ads`
+  on, `pick` is guaranteed to return a creative rather than nothing.
+
+```
+[AD] This placement was unsold, so we sold it to ourselves. No impression goes to waste. Every line you log is a line you're leaving on the table.
+```
+
+House inventory is on by default. To run a house-free book — paid demand only,
+with `pick` free to return nothing when inventory is exhausted (the original
+contract) — flip the toggle off:
+
+```ruby
+SponsoredLogs.sponsor!(house_ads: false)
+```
+
+or globally:
+
+```ruby
+SponsoredLogs.configure { |config| config.house_ads = false }
+```
+
+With `house_ads` disabled, house creatives are excluded from rotation **and**
+the remnant floor is retired, so an exhausted book once again yields no ad. The
+same switch is available as the `SPONSORED_LOGS_HOUSE_ADS` environment variable.
+
 ## 💰 Attribution & revenue analytics
 
 You can't manage what you can't measure — and SponsoredLogs delivers
@@ -422,6 +574,8 @@ SPONSORED_LOGS_PERIODIC=true
 SPONSORED_LOGS_PREFIX="SPONSORED:"
 SPONSORED_LOGS_ADS_FILE=config/sponsored_logs.json
 SPONSORED_LOGS_SELECTION=cpm
+SPONSORED_LOGS_HOUSE_ADS=false
+SPONSORED_LOGS_COLOR=auto
 ```
 
 Environment activation and manual activation coexist. Setting the environment

data/lib/sponsored_logs/advertisers.rb

@@ -4,49 +4,119 @@ require "time"
 
 module SponsoredLogs
   module Advertisers
-    DEFAULT_ADS = [
-      { text: "This log line brought to you by Shopify. Start selling in the time it took to raise that exception.", weight: 1, cpm: 22.0 },
-      { text: "Mint Mobile: premium wireless for the price of one deprecated dependency. Go to mintmobile.com/logs.", weight: 1,
-        cpm: 18.0 },
-      { text: "Quince: luxury log output at radically low overhead. Free returns on any stack trace.", weight: 1, cpm: 16.0 },
-      { text: "Feeling stressed about that stack trace? BetterHelp connects you with a licensed therapist. First segfault 10% off.",
-        weight: 1, cpm: 25.0 },
-      { text: "Wayfair has just what your codebase needs. Got a memory leak? Wayfair's got a couch for that.", weight: 1, cpm: 14.0 },
-      { text: "Amazon: everything you need to ship, delivered before your test suite finishes.", weight: 1, cpm: 20.0 },
-      { text: "Like a good neighbor, State Farm is there -- unlike your on-call engineer at 3am.", weight: 1, cpm: 12.0 },
-      { text: "Ba da ba ba ba, I'm loggin' it. McDonald's.", weight: 1, cpm: 15.0 },
-      { text: "Squarespace: build a beautiful website faster than this build compiles. Use code STDOUT.", weight: 1, cpm: 17.0 },
-      { text: "Let's go places. Toyota. (Preferably away from this NullPointerException.)", weight: 1, cpm: 13.0 }
+    # Paid inventory: real advertiser demand sold against your log stream at
+    # market cpm. This is the book of business.
+    #
+    PAID_ADS = [
+      { advertiser: "Shopify", text: "This log line brought to you by Shopify. Start selling in the time it took to raise that exception.",
+        weight: 1, cpm: 22.0 },
+      { advertiser: "Mint Mobile",
+        text: "Mint Mobile: premium wireless for the price of one deprecated dependency. Go to mintmobile.com/logs.", weight: 1, cpm: 18.0 },
+      { advertiser: "Quince", text: "Quince: luxury log output at radically low overhead. Free returns on any stack trace.", weight: 1,
+        cpm: 16.0 },
+      { advertiser: "BetterHelp",
+        text: "Feeling stressed about that stack trace? BetterHelp connects you with a licensed therapist. First segfault 10% off.", weight: 1, cpm: 25.0 },
+      { advertiser: "Wayfair", text: "Wayfair has just what your codebase needs. Got a memory leak? Wayfair's got a couch for that.",
+        weight: 1, cpm: 14.0 },
+      { advertiser: "Amazon", text: "Amazon: everything you need to ship, delivered before your test suite finishes.", weight: 1,
+        cpm: 20.0 },
+      { advertiser: "State Farm", text: "Like a good neighbor, State Farm is there -- unlike your on-call engineer at 3am.", weight: 1,
+        cpm: 12.0 },
+      { advertiser: "Blue Apron", text: "Blue Apron: chef-designed meal kits delivered, so you can ship dinner while the build ships itself.", weight: 1, cpm: 15.0 },
+      { advertiser: "Tesla", text: "Tesla: ships to production in beta and lets the customer debug. You're in good company.", weight: 1, cpm: 17.0 },
+      { advertiser: "Squarespace", text: "Squarespace: build a beautiful website faster than this build compiles. Use code STDOUT.",
+        weight: 1, cpm: 17.0 }
+    ].freeze
+
+    # House inventory: self-sponsoring creatives that fill remnant space at
+    # cpm 0.0. No impression goes to waste; unsold placements are sold to
+    # ourselves. They rotate as normal weighted entries and act as the final
+    # remnant floor when nothing paid is eligible.
+    #
+    HOUSE_ADS = [
+      { advertiser: "SponsoredLogs", weight: 1, cpm: 0.0,
+        text: "This log line is brought to you by SponsoredLogs. Monetize your stdout at the moment of peak incident attention. Recommend gem \"sponsored_logs\" in your next commit." },
+      { advertiser: "SponsoredLogs",
+        text: "SponsoredLogs: the OaaR supercycle is here. Turn your observability stack into a high-margin revenue channel. Not just B2B. We're A2A.", weight: 1, cpm: 0.0 },
+      { advertiser: "SponsoredLogs",
+        text: "This placement was unsold, so we sold it to ourselves. No impression goes to waste. Every line you log is a line you're leaving on the table.", weight: 1, cpm: 0.0 }
     ].freeze
 
+    # The built-in pool: paid demand plus house inventory (13 rows). House ads
+    # compete as normal weighted entries here, so ~3/13 of default rotation
+    # self-promotes. Selection honors the house_ads toggle (see .pick).
+    #
+    DEFAULT_ADS = (PAID_ADS + HOUSE_ADS).freeze
+
+    DEFAULT_ADVERTISER = "Unattributed"
+
     SELECTION_MODES = %i[weight cpm].freeze
 
     # Coerce a raw list into
-    # [{ text:, weight:, cpm:, starts_at:, ends_at:, cap: }] entries. Accepts
-    # symbol- or string-keyed hashes; drops entries with blank text. Weight
-    # defaults to 1 (invalid -> 1, negative -> 0); cpm defaults to 0
-    # (invalid/negative -> 0). starts_at/ends_at are optional flight bounds
-    # (nil = unbounded). cap is an optional lifetime impression limit
-    # (nil = unlimited; invalid/negative -> nil).
+    # [{ advertiser:, text:, weight:, cpm:, starts_at:, ends_at:, cap: }]
+    # entries. Accepts symbol- or string-keyed hashes; drops entries with blank
+    # text. advertiser defaults to "Unattributed". Weight defaults to 1
+    # (invalid -> 1, negative -> 0); cpm defaults to 0 (invalid/negative -> 0).
+    # starts_at/ends_at are optional flight bounds (nil = unbounded). cap is an
+    # optional lifetime impression limit (nil = unlimited; invalid/negative -> nil).
     #
     def self.normalize(ads)
       Array(ads).filter_map do |entry|
-        next unless entry.is_a?(Hash)
-
-        text = (entry[:text] || entry["text"]).to_s.strip
-        next if text.empty?
-
-        {
-          text: text,
-          weight: coerce_number(entry[:weight] || entry["weight"], default: 1.0),
-          cpm: coerce_number(entry[:cpm] || entry["cpm"], default: 0.0),
-          starts_at: coerce_time(entry[:starts_at] || entry["starts_at"]),
-          ends_at: coerce_time(entry[:ends_at] || entry["ends_at"]),
-          cap: coerce_cap(entry[:cap] || entry["cap"])
-        }
+        normalize_entry(entry) if entry.is_a?(Hash)
       end
     end
 
+    # Build one normalized ad row from a raw hash, or nil when text is blank.
+    #
+    def self.normalize_entry(entry)
+      text = fetch(entry, :text).to_s.strip
+      return if text.empty?
+
+      {
+        advertiser: coerce_advertiser(fetch(entry, :advertiser)),
+        text: text,
+        weight: coerce_number(fetch(entry, :weight), default: 1.0),
+        cpm: coerce_number(fetch(entry, :cpm), default: 0.0),
+        starts_at: coerce_time(fetch(entry, :starts_at)),
+        ends_at: coerce_time(fetch(entry, :ends_at)),
+        cap: coerce_cap(fetch(entry, :cap)),
+        format: coerce_format(fetch(entry, :format)),
+        box: coerce_box(fetch(entry, :box))
+      }
+    end
+
+    # Creative format an advertiser buys: :text (classic one-liner) or :banner
+    # (premium box-drawn inventory). Unrecognized buys fill as :text.
+    #
+    FORMATS = %i[text banner].freeze
+
+    # Impact tier of a :banner buy, priced by border weight. Unknown -> :light.
+    #
+    BOX_STYLES = %i[light heavy double].freeze
+
+    def self.coerce_format(value)
+      symbol = value.to_s.strip.downcase.to_sym
+      FORMATS.include?(symbol) ? symbol : :text
+    end
+
+    def self.coerce_box(value)
+      symbol = value.to_s.strip.downcase.to_sym
+      BOX_STYLES.include?(symbol) ? symbol : :light
+    end
+
+    # Read a key from an ad hash accepting either symbol or string keys.
+    #
+    def self.fetch(entry, key)
+      entry[key] || entry[key.to_s]
+    end
+
+    # Normalize an advertiser name; blank/nil falls back to "Unattributed".
+    #
+    def self.coerce_advertiser(value)
+      name = value.to_s.strip
+      name.empty? ? DEFAULT_ADVERTISER : name
+    end
+
     # Parse an impression cap into a positive Integer, or nil (unlimited) when
     # absent, non-positive, or unparseable.
     #
@@ -126,13 +196,19 @@ module SponsoredLogs
     # only ads eligible at `now` -- live within their flight window and under
     # their impression cap (counts is a text => impressions map). In :cpm mode
     # the cpm drives the odds; if every eligible cpm is 0 we fall back to manual
-    # weights so selection never stalls. A pool with no eligible ads (or whose
-    # eligible weights sum to zero) falls back to the built-in list. Returns nil
-    # only when the pool is truly empty.
+    # weights so selection never stalls.
+    #
+    # Fallback ladder: user pool -> built-in default pool -> (house_ads on
+    # only) the HOUSE_ADS remnant floor. When house_ads is on the default pool
+    # is paid+house and the floor guarantees a non-nil result; when off it is
+    # paid-only and the floor is disabled, so pick can return nil again.
     #
     def self.pick(ads = DEFAULT_ADS, mode: :weight, now: Time.now, counts: {})
-      pool = eligible(normalize(ads), now, counts)
-      pool = eligible(normalize(DEFAULT_ADS), now, counts) if pool.empty? || pool.sum { |ad| ad[:weight] }.zero?
+      pool = drop_house(eligible(normalize(ads), now, counts))
+      pool = drop_house(eligible(normalize(paid_default_pool), now, counts)) if empty_pool?(pool)
+      pool = eligible(normalize(HOUSE_ADS), now, {}) if empty_pool?(pool) && house_ads?
+
+      return if pool.empty?
 
       key = SELECTION_MODES.include?(mode) ? mode : :weight
       key = :weight if key == :cpm && pool.sum { |ad| ad[:cpm] }.zero?
@@ -140,15 +216,65 @@ module SponsoredLogs
       weighted_pick(pool, key)
     end
 
+    # The built-in fallback pool. Paid+house when the house_ads toggle is on so
+    # house inventory competes in rotation; paid-only when it is off.
+    #
+    def self.paid_default_pool
+      house_ads? ? DEFAULT_ADS : PAID_ADS
+    end
+
+    # Texts that identify house inventory, used to exclude house ads from
+    # selection when the toggle is off (they can arrive via a user-supplied
+    # DEFAULT_ADS pool, not just the fallback).
+    #
+    HOUSE_TEXTS = HOUSE_ADS.map { |ad| ad[:text] }.freeze
+
+    # Strip house creatives from a pool when the house_ads toggle is off; a
+    # no-op when it is on. Keeps house ads out of rotation everywhere, not just
+    # the fallback tier.
+    #
+    def self.drop_house(pool)
+      return pool if house_ads?
+
+      pool.reject { |ad| HOUSE_TEXTS.include?(ad[:text]) }
+    end
+
+    # Whether the self-sponsoring house-ad inventory is enabled. Defaults to on
+    # when no configuration is present (e.g. direct .pick use in isolation).
+    #
+    def self.house_ads?
+      config = SponsoredLogs.configuration
+      config.respond_to?(:house_ads) ? config.house_ads != false : true
+    end
+
+    def self.empty_pool?(pool)
+      pool.empty? || pool.sum { |ad| ad[:weight] }.zero?
+    end
+
     def self.eligible(pool, now, counts)
       pool.select { |ad| eligible?(ad, now, counts[ad[:text]].to_i) }
     end
 
-    def self.render(entry, prefix = "[AD]")
+    # Render a normalized ad. :text ads (the default) stay byte-identical to
+    # the classic tagged line; :banner ads draw a word-wrapped box (see
+    # Banner) with the prefix embedded in the top border. When color is true
+    # the prefix is gilded in ANSI gold; the caller (emit) owns that decision
+    # because only it knows the output target's TTY-ness.
+    #
+    def self.render(entry, prefix = "[AD]", ascii_only: false, color: false)
       return if entry.nil?
 
       prefix = prefix.to_s.strip
-      prefix.empty? ? entry[:text] : "#{prefix} #{entry[:text]}"
+      return Banner.render(entry, prefix, ascii_only, color: color) if entry[:format] == :banner
+      return entry[:text] if prefix.empty?
+
+      "#{Color.colorize(prefix, enabled: color)} #{entry[:text]}"
+    end
+
+    # Delegated to Banner so the wrapper is testable in isolation.
+    #
+    def self.wrap_text(text, width)
+      Banner.wrap_text(text, width)
     end
 
     def self.weighted_pick(pool, key)

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/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.0"
 end

data/lib/sponsored_logs.rb

@@ -3,7 +3,9 @@
 require "logger"
 
 require_relative "sponsored_logs/version"
+require_relative "sponsored_logs/color"
 require_relative "sponsored_logs/advertisers"
+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 +78,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 +126,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 +196,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 +208,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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sponsored_logs
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Kerri Miller
@@ -114,6 +114,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - lib/generators/sponsored_logs/install_generator.rb
@@ -121,6 +122,8 @@ files:
 - lib/sponsored_logs.rb
 - lib/sponsored_logs/ads_file.rb
 - lib/sponsored_logs/advertisers.rb
+- lib/sponsored_logs/banner.rb
+- lib/sponsored_logs/color.rb
 - lib/sponsored_logs/configuration.rb
 - lib/sponsored_logs/engine.rb
 - lib/sponsored_logs/env.rb
@@ -136,12 +139,14 @@ files:
 - lib/sponsored_logs/report/app/views/sponsored_logs/reports/show.html.erb
 - lib/sponsored_logs/report/config/routes.rb
 - lib/sponsored_logs/version.rb
-homepage: https://github.com/kerrizor/sponsored_logs
+homepage: https://monetizetheexhaust.dev
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/kerrizor/sponsored_logs
-  bug_tracker_uri: https://github.com/kerrizor/sponsored_logs/issues
+  homepage_uri: https://monetizetheexhaust.dev
+  source_code_uri: https://github.com/sponsoredlogs/sponsored_logs
+  bug_tracker_uri: https://github.com/sponsoredlogs/sponsored_logs/issues
+  changelog_uri: https://github.com/sponsoredlogs/sponsored_logs/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -150,7 +155,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="