dboard 3.2.0 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ca84c9c7461e1f0aefa5463e6796774e3fcb41d909430f0447bf9c240609753
-  data.tar.gz: e0f59d7466411b2dcfff3799f521271950dfab15e1322b5d15aaaca66b621ea7
+  metadata.gz: d1b44cea534d5b5317f70d02d39b43cd2d072b3eca3446243f0b98bba7569823
+  data.tar.gz: d70dee83fae380054f04250252e9956e29630b7f05a9eb49f4f14e536891ee82
 SHA512:
-  metadata.gz: a32643a51fbdd0acb92d4b7e3c7f88db9f2749316918867e700e6582ac0956814a0789a6df1934f71017623716b55b69c8510886d3b5156f2be9183b474ddfc5
-  data.tar.gz: e222ceed0499f6bac7622f690cc71815d095252dc6158c7db48007e595ba57b8e617bcc7e033030910ae7088071ee555f699ba93ab701753db053c0c01728f13
+  metadata.gz: 264dc148bf21c0dbce7173c42f412c5d55d54c27ff26124ac692485c4d7538e66dafd920adc31bb79a595b8069bcd635f07513bc7736ce81205038d5020b0e14
+  data.tar.gz: 7640bd50fab1e0a0f43641462657482ba996bff8e0185e6d76f6537a6c2fafdcfe5467201cbd8f45fe5508bc396ddcb5b5bef61ed525c82e80a39236f61237e2

data/.github/workflows/ci.yml

@@ -27,27 +27,3 @@ jobs:
           bundler-cache: true # runs 'bundle install' and caches installed gems automatically
       - name: Run tests
         run: bundle exec rake
-
-  release:
-    if: github.ref_name == github.event.repository.default_branch
-    needs: test
-    environment: Rubygems
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: "3.4"
-          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-      - name: Publish gem
-        run: |
-          mkdir -p $HOME/.gem
-          touch $HOME/.gem/credentials
-          chmod 0600 $HOME/.gem/credentials
-          printf -- '---\n:rubygems_api_key: %s\n' "$RUBYGEMS_API_KEY" > "$HOME/.gem/credentials"
-          sed -i -E "s/(VERSION = \"[0-9.]+)\"/\1.${GITHUB_RUN_NUMBER}\"/" lib/version.rb # Add build number to version
-          gem build *.gemspec
-          gem push *.gem
-        env:
-          RUBYGEMS_API_KEY: "${{secrets.RUBYGEMS_API_KEY}}"

data/README.md

@@ -23,19 +23,13 @@ Things dboard do for you:
 
 Refreshing sources:
 
-Each source defines `update_interval` (seconds), and the collector polls it on that cadence.
+Each source defines `update_interval` (seconds); the collector polls it on that cadence and pushes the result to the dashboard.
 
-You can also trigger an out-of-band refresh (e.g. from an inbound webhook) with `Dboard::Collector.request_update(:key)`, where `:key` is the key the source was registered under. This is throttled: the first trigger refreshes immediately, and further triggers inside the floor window are coalesced into a single trailing refresh, so a flood of triggers never causes more than one refresh per floor. The poll and manual triggers share one clock, so a manual refresh lets the next poll cycle skip its fetch.
+To refresh a source between scheduled polls (e.g. from an inbound webhook), call `Dboard::Collector.request_update(:key)`, where `:key` is the key the source was registered under. On-demand refreshes are throttled: the first fires immediately and rapid repeats collapse into at most one refresh per floor. The floor defaults to 30 seconds; a source can lower it with `min_update_interval` (seconds), capped at its `update_interval`.
 
-The floor defaults to 30 seconds. A source may override it by defining `min_update_interval` (seconds). The effective floor is capped at the source's `update_interval`, so it can never exceed the poll interval.
+For a targeted refresh, pass an argument: `Dboard::Collector.request_update(:key, arg)`. A source receives it by defining `fetch(args = nil)`: `args` is `nil` for a full refresh and an array of the requested arguments for a targeted one, so the source can refresh only what changed (e.g. the single project named in a webhook).
 
-Targeted refreshes:
-
-`request_update` also takes an optional argument for a targeted refresh: `Dboard::Collector.request_update(:key, arg)`. The argument is opaque; the framework forwards it verbatim to the source and never inspects it. Omitting it (or passing `nil`) means a full refresh of the whole source.
-
-A source opts in by defining `fetch(args = nil)`. It receives `nil` for a full refresh (a scheduled poll or a no-arg `request_update`) and an array of the accumulated arguments for a targeted refresh. Arguments are batched the same way triggers are coalesced: the leading refresh carries the first argument, and any arguments that arrive during the active window are delivered together in the one trailing refresh. A no-arg (full) request queued during a burst wins over pending arguments, since a full refresh already covers them. The poll shares the same clock and floor as targeted refreshes, so both together still fetch at most once per floor.
-
-Publishing stays wholesale: the collector always replaces the stored blob for the key. A source doing a targeted refresh must therefore read its current state (e.g. from the cache) and return the full merged blob, not only the refreshed part.
+Publishing is wholesale: the collector always replaces the stored blob for a key, so a targeted refresh must return the full merged blob (reading current state from the cache if needed), not only the part it refreshed.
 
 Data flow:
 

data/lib/collector.rb

@@ -50,7 +50,8 @@ module Dboard
           wait_a_little_bit_to_not_start_all_fetches_at_once
 
           loop do
-            update_in_thread(source, instance)
+            request_update(source)
+            sleep instance.update_interval
           end
         end
       end
@@ -110,11 +111,15 @@ module Dboard
     private
 
     def fetch_source(instance, batch)
-      if batch.nil? || batch.any? { |entry| entry.equal?(FULL) }
-        instance.fetch
-      else
-        instance.fetch(batch)
-      end
+      full_batch?(batch) ? instance.fetch : instance.fetch(batch)
+    end
+
+    def full_batch?(batch)
+      batch.nil? || batch.any? { |entry| entry.equal?(FULL) }
+    end
+
+    def describe_batch(batch)
+      full_batch?(batch) ? "full" : "targeted: #{batch.join(", ")}"
     end
 
     def decide_request(active, last_update_at, floor, now)
@@ -182,25 +187,13 @@ module Dboard
         }
         return false if batch.equal?(SKIP)
 
+        started = monotonic_now
         update_source(source, instance, batch)
+        puts "#{source} refreshed (#{describe_batch(batch)}) in #{(monotonic_now - started).round(1)}s"
         true
       }
     end
 
-    def update_in_thread(source, instance)
-      puts "#{source} polling..."
-      fired = perform_refresh(source, instance, instance.update_interval)
-      time_until_next_update = @mutex.synchronize {
-        remaining = instance.update_interval - (monotonic_now - @last_update_at[source])
-        remaining < 0 ? 0 : remaining
-      }
-      puts "#{source} #{fired ? "updated" : "still fresh"}, will poll again in #{time_until_next_update} seconds (interval: #{instance.update_interval})."
-      sleep time_until_next_update
-    rescue Exception => ex
-      puts "Something failed outside the update_source method. #{ex.message}"
-      puts ex.backtrace
-    end
-
     def min_interval_for(instance)
       override = instance.respond_to?(:min_update_interval) ? instance.min_update_interval : DEFAULT_MIN_INTERVAL
       [ override, instance.update_interval ].min

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Dboard
-  VERSION = "3.2.0"
+  VERSION = "3.2.1"
 end

data/spec/collector_spec.rb

@@ -245,19 +245,6 @@ RSpec.describe Dboard::Collector do
     end
 
     describe "the shared clock" do
-      it "lets a manual refresh make the next poll cycle skip its fetch" do
-        source = double(:source, update_interval: 100)
-        allow(source).to receive(:fetch).and_return({ ok: true })
-        collector.register_source(:src, source)
-        use_fake_clock
-        run_workers_inline
-
-        collector.request_update(:src)
-        collector.send(:update_in_thread, :src, source)
-
-        expect(source).to have_received(:fetch).once
-      end
-
       it "re-evaluates a scheduled trailing when a poll refreshes during its sleep" do
         source = double(:source, update_interval: 100, min_update_interval: 10)
         clock = FakeClock.new
@@ -387,26 +374,6 @@ RSpec.describe Dboard::Collector do
         expect(Dboard::Publisher).to have_received(:publish).with(:src, { ok: true })
       end
 
-      it "leaves pending args untouched when a poll wins and delivers them on the next on-demand refresh" do
-        source = double(:source, update_interval: 100)
-        fetch_args = []
-        allow(source).to receive(:fetch) { |*args| fetch_args << args.first; { ok: true } }
-        collector.register_source(:src, source)
-        use_fake_clock
-        workers = capture_worker_blocks
-
-        collector.request_update(:src, "a")
-        collector.request_update(:src, "p")
-        expect(collector.instance_variable_get(:@pending)[:src]).to eq([ "p" ])
-
-        collector.send(:update_in_thread, :src, source)
-        expect(collector.instance_variable_get(:@pending)[:src]).to eq([ "p" ])
-
-        workers.each(&:call)
-
-        expect(fetch_args).to eq([ nil, [ "a" ], [ "p" ] ])
-      end
-
       it "retries the retained leading snapshot when a poll refreshes before it runs" do
         source = double(:source, update_interval: 100)
         fetch_args = []
@@ -421,20 +388,6 @@ RSpec.describe Dboard::Collector do
 
         expect(fetch_args).to eq([ [ "p" ] ])
       end
-
-      it "shares one clock between a partial refresh and the poll" do
-        source = double(:source, update_interval: 100)
-        allow(source).to receive(:fetch).and_return({ ok: true })
-        collector.register_source(:src, source)
-        use_fake_clock
-        run_workers_inline
-
-        collector.request_update(:src, "p")
-        collector.send(:update_in_thread, :src, source)
-
-        expect(source).to have_received(:fetch).with([ "p" ]).once
-        expect(source).to have_received(:fetch).with(no_args).exactly(0).times
-      end
     end
 
     describe "under real threads" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dboard
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.2.1
 platform: ruby
 authors:
 - Joakim Kolsjö