@daemonitor/plugins 1.1.31 → 1.1.33

package/dist/plugins/index.js

@@ -11,6 +11,8 @@ import { createSnmpPlugin } from "./monitoring/SnmpPlugin.js";
 import { createThreeCXPlugin } from "./monitoring/ThreeCXPlugin.js";
 import { createTplinkPlugin } from "./monitoring/TplinkPlugin.js";
 import { createPatroniPlugin } from "./monitoring/PatroniPlugin.js";
+import { createAdsensePlugin } from "./monitoring/AdsensePlugin.js";
+import { createGa4Plugin } from "./monitoring/Ga4Plugin.js";
 // In future, implement other plugin factory functions using the same pattern
 // import { createOSPlugin } from "./monitoring/OSPlugin.js"
 // import { createMongoDBPlugin } from "./monitoring/MongoDBPlugin.js"
@@ -33,6 +35,8 @@ export default {
     ThreeCX: createThreeCXPlugin,
     Tplink: createTplinkPlugin,
     Patroni: createPatroniPlugin,
+    Adsense: createAdsensePlugin,
+    Ga4: createGa4Plugin,
     // CloudflarePlugin: createCloudflarePlugin,
     // EwelinkPlugin: createEwelinkPlugin,
     // MongoDBPlugin: createMongoDBPlugin,

package/dist/plugins/monitoring/AdsensePlugin.js

@@ -0,0 +1,227 @@
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+// Google AdSense earnings monitor.
+//
+// AdSense has no service-account access, so this runs on a user refresh token
+// (scope adsense.readonly) minted once by hand. Each poll trades it for a
+// one-hour access token and pulls ONE report: earnings and page views per day,
+// from whichever is earlier of the 1st of the month or 29 days ago, through
+// today. Every figure on the tile (today, yesterday, 7 days, month to date, RPM,
+// the daily sparkline) is summed locally from those rows, so the numbers cannot
+// disagree with each other the way separate report calls can mid-update.
+//
+// Dates are the ACCOUNT's time zone, not this host's: "today" for an account in
+// New York is still yesterday on a UTC box for a few hours every night.
+const TOKEN_URL = "https://oauth2.googleapis.com/token";
+const API = "https://adsense.googleapis.com/v2";
+/** YYYY-MM-DD shifted by whole days. */
+export function shiftDate(date, days) {
+    const t = new Date(`${date}T00:00:00Z`);
+    t.setUTCDate(t.getUTCDate() + days);
+    return t.toISOString().slice(0, 10);
+}
+/** Today's date as the account sees it. */
+export function todayIn(timeZone, now = new Date()) {
+    // en-CA formats as YYYY-MM-DD.
+    return new Intl.DateTimeFormat("en-CA", { timeZone: timeZone || "UTC" }).format(now);
+}
+/** Earlier of the 1st of this month and 29 days back, so one report covers both windows. */
+export function reportStart(today) {
+    const monthStart = `${today.slice(0, 7)}-01`;
+    const back = shiftDate(today, -29);
+    return back < monthStart ? back : monthStart;
+}
+export function reportUrl(account, start, end, bySite = false) {
+    const q = new URLSearchParams({ dateRange: "CUSTOM", reportingTimeZone: "ACCOUNT_TIME_ZONE", dimensions: "DATE" });
+    // DOMAIN_NAME, not OWNED_SITE_DOMAIN_NAME: the owned-site rows nest (archpaper.com
+    // contains www.archpaper.com and jobs.archpaper.com), so they double count.
+    if (bySite)
+        q.append("dimensions", "DOMAIN_NAME");
+    for (const [k, v] of [["startDate", start], ["endDate", end]]) {
+        const [y, m, d] = v.split("-").map(Number);
+        q.set(`${k}.year`, String(y));
+        q.set(`${k}.month`, String(m));
+        q.set(`${k}.day`, String(d));
+    }
+    q.append("metrics", "ESTIMATED_EARNINGS");
+    q.append("metrics", "PAGE_VIEWS");
+    q.append("metrics", "CLICKS");
+    return `${API}/${account}/reports:generate?${q}`;
+}
+/** reports:generate response -> per-day rows. Columns are found by header name, not position. */
+export function parseReport(report) {
+    const headers = Array.isArray(report?.headers) ? report.headers : [];
+    const col = (name) => headers.findIndex((h) => h?.name === name);
+    const [iDate, iEarn, iViews, iClicks] = [col("DATE"), col("ESTIMATED_EARNINGS"), col("PAGE_VIEWS"), col("CLICKS")];
+    if (iDate < 0 || iEarn < 0)
+        throw new Error("unexpected report shape (no DATE/ESTIMATED_EARNINGS column)");
+    // A day with no traffic has no row at all, so an empty report is valid.
+    const rows = Array.isArray(report?.rows) ? report.rows : [];
+    return {
+        currency: headers[iEarn]?.currencyCode || "USD",
+        days: rows.map((r) => ({
+            date: String(r?.cells?.[iDate]?.value || ""),
+            earnings: Number(r?.cells?.[iEarn]?.value) || 0,
+            pageViews: iViews < 0 ? 0 : Number(r?.cells?.[iViews]?.value) || 0,
+            clicks: iClicks < 0 ? 0 : Number(r?.cells?.[iClicks]?.value) || 0,
+        })),
+    };
+}
+/** A DATE x DOMAIN_NAME report -> per-day rows keyed by site (hostname without a leading www). */
+export function parseSiteReport(report) {
+    const headers = Array.isArray(report?.headers) ? report.headers : [];
+    const iDomain = headers.findIndex((h) => h?.name === "DOMAIN_NAME");
+    const out = new Map();
+    if (iDomain < 0)
+        return out;
+    const { days } = parseReport(report);
+    const rows = Array.isArray(report?.rows) ? report.rows : [];
+    rows.forEach((r, i) => {
+        // www.example.com and example.com are one site to a reader, so they merge.
+        const domain = String(r?.cells?.[iDomain]?.value || "").replace(/^www\./, "");
+        if (!domain)
+            return;
+        if (!out.has(domain))
+            out.set(domain, []);
+        const list = out.get(domain);
+        const same = list.find((d) => d.date === days[i].date);
+        if (same) {
+            same.earnings += days[i].earnings;
+            same.pageViews += days[i].pageViews;
+            same.clicks += days[i].clicks;
+        }
+        else
+            list.push({ ...days[i] });
+    });
+    return out;
+}
+const MAX_SITES = 20;
+/**
+ * Per-site figures, biggest earner first. Domains that earned nothing in the
+ * window are dropped: AdSense lists every hostname an ad tag loaded on, which
+ * includes admin hosts and previews that are noise here. `daily` is earnings
+ * only, to keep the payload small.
+ */
+export function summarizeSites(bySite, today) {
+    return [...bySite.entries()]
+        .map(([domain, days]) => {
+        const sum = summarize(days, today);
+        return { domain, ...sum, daily: sum.daily.map((d) => cents(d.earnings)), window: days.reduce((t, d) => t + d.earnings, 0) };
+    })
+        .filter((s) => s.window > 0)
+        .sort((a, b) => b.window - a.window)
+        .slice(0, MAX_SITES)
+        .map(({ window: _window, ...site }) => site);
+}
+const cents = (n) => Math.round(n * 100) / 100;
+/** Roll per-day rows up into the figures the tile shows. `last7` includes today, as AdSense's own "Last 7 days" does. */
+export function summarize(days, today) {
+    const by = new Map(days.map((d) => [d.date, d]));
+    const day = (date) => by.get(date) || { date, earnings: 0, pageViews: 0, clicks: 0 };
+    const span = (n) => Array.from({ length: n }, (_, i) => day(shiftDate(today, i - n + 1)));
+    const week = span(7);
+    const last7 = week.reduce((s, d) => s + d.earnings, 0);
+    const pageViews7 = week.reduce((s, d) => s + d.pageViews, 0);
+    const month = today.slice(0, 7);
+    return {
+        today: cents(day(today).earnings),
+        yesterday: cents(day(shiftDate(today, -1)).earnings),
+        last7: cents(last7),
+        monthToDate: cents(days.filter((d) => d.date.startsWith(month)).reduce((s, d) => s + d.earnings, 0)),
+        pageViews7,
+        clicks7: week.reduce((s, d) => s + d.clicks, 0),
+        // Page RPM over the same 7 days: earnings per thousand page views.
+        rpm: pageViews7 ? cents((last7 / pageViews7) * 1000) : 0,
+        // Gap-filled so the sparkline has one point per day, oldest first.
+        daily: span(30),
+    };
+}
+export async function getJson(url, init, timeout) {
+    const res = await fetch(url, { ...init, signal: AbortSignal.timeout(timeout) });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+        const e = new Error(body?.error_description || body?.error?.message || body?.error || `HTTP ${res.status}`);
+        e.code = typeof body?.error === "string" ? body.error : body?.error?.status;
+        throw e;
+    }
+    return body;
+}
+/** Trade a refresh token for a one-hour access token. Shared with the ga4 plugin. */
+export async function googleAccessToken(cfg, timeout) {
+    const tok = await getJson(TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "refresh_token",
+            client_id: cfg.clientId || "",
+            client_secret: cfg.clientSecret || "",
+            refresh_token: cfg.refreshToken || "",
+        }).toString(),
+    }, timeout);
+    return tok.access_token;
+}
+export function createAdsensePlugin() {
+    let refreshTimer = null;
+    // Resolved once: the account and its time zone do not change between polls.
+    let account = null;
+    const collect = async (cfg) => {
+        const timeout = cfg.timeout || 15000;
+        const auth = { headers: { Authorization: `Bearer ${await googleAccessToken(cfg, timeout)}` } };
+        if (!account) {
+            const list = (await getJson(`${API}/accounts`, auth, timeout))?.accounts || [];
+            const a = cfg.accountId ? list.find((x) => x.name === cfg.accountId) : list[0];
+            if (!a)
+                throw new Error(cfg.accountId ? `account ${cfg.accountId} not visible to this token` : "no AdSense account visible to this token");
+            account = { name: a.name, displayName: a.displayName, timeZone: a.timeZone?.id };
+        }
+        const today = todayIn(account.timeZone);
+        const start = reportStart(today);
+        const { currency, days } = parseReport(await getJson(reportUrl(account.name, start, today), auth, timeout));
+        // The per-site breakdown is extra: if it fails, the account totals still report.
+        let sites = [];
+        try {
+            sites = summarizeSites(parseSiteReport(await getJson(reportUrl(account.name, start, today, true), auth, timeout)), today);
+        }
+        catch { /* totals only */ }
+        return {
+            // The account's own name ("The Architect's Newspaper") labels the service.
+            // It overrides the plugin's instance name, which only says "AdSense".
+            ...(account.displayName ? { name: account.displayName } : {}),
+            accountId: account.name,
+            currency,
+            asOf: today,
+            ...summarize(days, today),
+            sites,
+        };
+    };
+    const refreshFn = async (plugin) => {
+        const cfg = (plugin.config || {});
+        if (!cfg.clientId || !cfg.clientSecret || !cfg.refreshToken) {
+            await plugin.send({ error: "adsense plugin needs clientId, clientSecret and refreshToken" });
+            return;
+        }
+        try {
+            await plugin.send(await collect(cfg));
+        }
+        catch (e) {
+            // invalid_grant = the refresh token was revoked or expired. Nothing the
+            // next poll can fix, so it is flagged apart from a transient API error.
+            await plugin.send({
+                error: String(e?.message || e).slice(0, 160),
+                ...(e?.code === "invalid_grant" ? { authExpired: true } : {}),
+            });
+        }
+    };
+    const monitorFn = async (plugin) => {
+        await refreshFn(plugin);
+        // AdSense figures lag by hours, so 15 minutes loses nothing. The server
+        // allows these rows 30 minutes of silence before calling them offline.
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 900000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("adsense", "adsense", "Google AdSense earnings (today, yesterday, 7 days, month to date, page RPM)", async () => { }, monitorFn, refreshFn, teardownFn);
+}
+export default createAdsensePlugin;

package/dist/plugins/monitoring/Ga4Plugin.js

@@ -0,0 +1,164 @@
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+import { getJson, googleAccessToken, shiftDate, todayIn } from "./AdsensePlugin.js";
+// Google Analytics 4 overview across every account and property the Google
+// login can see.
+//
+// Runs on a user refresh token with scope analytics.readonly, minted the same
+// way as the adsense plugin's (client/etc/adsense-auth.mjs --source=ga4).
+//
+// Each poll lists the account/property tree from the Admin API, then for each
+// property asks the Data API for: active users right now (realtime), users,
+// sessions and page views for today, yesterday and the last 7 days, and 30
+// days of daily figures. 7-day users come from GA itself, never from summing
+// days: one person on three days is one user, not three.
+//
+// The report carries its own 30-day history, so the server stores no history
+// rows for this type. Hiding properties and nicknames live in the portal.
+const ADMIN = "https://analyticsadmin.googleapis.com/v1beta";
+const DATA = "https://analyticsdata.googleapis.com/v1beta";
+const DAYS = 30;
+// Parallel property requests. GA quotas are per property, so this only bounds
+// how hard one poll hits the network.
+const CONCURRENCY = 4;
+const ZERO = { users: 0, sessions: 0, views: 0 };
+const METRICS = [{ name: "activeUsers" }, { name: "sessions" }, { name: "screenPageViews" }];
+/** accountSummaries response -> accounts with their GA4 properties. */
+export function parseAccounts(summaries) {
+    return (summaries || []).map((a) => ({
+        id: String(a?.account || "").replace(/^accounts\//, ""),
+        name: String(a?.displayName || a?.account || ""),
+        properties: (a?.propertySummaries || [])
+            .filter((p) => !p?.propertyType || p.propertyType === "PROPERTY_TYPE_ORDINARY")
+            .map((p) => ({ id: String(p?.property || "").replace(/^properties\//, ""), name: String(p?.displayName || p?.property || "") })),
+    }));
+}
+const num = (v) => Number(v?.value) || 0;
+const totals = (row) => row ? { users: num(row.metricValues?.[0]), sessions: num(row.metricValues?.[1]), views: num(row.metricValues?.[2]) } : { ...ZERO };
+/**
+ * batchRunReports response -> the figures the portal shows.
+ * Report 0: no dimensions, three named date ranges (today, yesterday, last7).
+ * Report 1: one row per date over the last 30 days.
+ */
+export function parseProperty(batch, now = new Date()) {
+    const [summary, byDate] = batch?.reports || [];
+    // A multi-range report adds a "dateRange" dimension holding each range's name.
+    const range = (name) => totals((summary?.rows || []).find((r) => r?.dimensionValues?.[0]?.value === name));
+    // Gap-fill the 30 days in the property's own time zone: GA leaves days with
+    // no traffic out entirely.
+    const today = todayIn(byDate?.metadata?.timeZone || summary?.metadata?.timeZone, now);
+    const by = new Map();
+    for (const r of byDate?.rows || []) {
+        const d = String(r?.dimensionValues?.[0]?.value || "");
+        if (d.length === 8)
+            by.set(`${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6)}`, totals(r));
+    }
+    const dates = Array.from({ length: DAYS }, (_, i) => shiftDate(today, i - DAYS + 1));
+    const days = dates.map((d) => by.get(d) || ZERO);
+    return {
+        asOf: today,
+        today: range("today"),
+        yesterday: range("yesterday"),
+        last7: range("last7"),
+        daily: {
+            start: dates[0],
+            users: days.map((d) => d.users),
+            sessions: days.map((d) => d.sessions),
+            views: days.map((d) => d.views),
+        },
+    };
+}
+/** runRealtimeReport -> users active in the last 30 minutes. No rows means zero. */
+export const parseRealtime = (r) => num(r?.rows?.[0]?.metricValues?.[0]);
+export const BATCH_BODY = {
+    requests: [
+        {
+            dateRanges: [
+                { startDate: "today", endDate: "today", name: "today" },
+                { startDate: "yesterday", endDate: "yesterday", name: "yesterday" },
+                { startDate: "6daysAgo", endDate: "today", name: "last7" },
+            ],
+            metrics: METRICS,
+        },
+        {
+            dateRanges: [{ startDate: `${DAYS - 1}daysAgo`, endDate: "today" }],
+            dimensions: [{ name: "date" }],
+            metrics: METRICS,
+            limit: DAYS + 5,
+        },
+    ],
+};
+async function inBatches(items, size, fn) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size)
+        out.push(...(await Promise.all(items.slice(i, i + size).map(fn))));
+    return out;
+}
+export function createGa4Plugin() {
+    let refreshTimer = null;
+    const collect = async (cfg) => {
+        const timeout = cfg.timeout || 20000;
+        const token = await googleAccessToken(cfg, timeout);
+        const get = (url) => getJson(url, { headers: { Authorization: `Bearer ${token}` } }, timeout);
+        const post = (url, body) => getJson(url, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        }, timeout);
+        // Every account and property this login can see, across pages.
+        const summaries = [];
+        let page = "";
+        do {
+            const r = await get(`${ADMIN}/accountSummaries?pageSize=200${page ? `&pageToken=${encodeURIComponent(page)}` : ""}`);
+            summaries.push(...(r?.accountSummaries || []));
+            page = r?.nextPageToken || "";
+        } while (page);
+        const allow = Array.isArray(cfg.accounts) && cfg.accounts.length ? new Set(cfg.accounts.map(String)) : null;
+        // Filtered before any report is requested: an account outside the list is
+        // never queried, so its figures never reach this customer.
+        const accounts = parseAccounts(summaries).filter((a) => !allow || allow.has(a.id));
+        for (const account of accounts) {
+            account.properties = await inBatches(account.properties, CONCURRENCY, async (p) => {
+                // One property failing (no access to its data, quota) must not hide the rest.
+                try {
+                    const [batch, realtime] = await Promise.all([
+                        post(`${DATA}/properties/${p.id}:batchRunReports`, BATCH_BODY),
+                        post(`${DATA}/properties/${p.id}:runRealtimeReport`, { metrics: [{ name: "activeUsers" }] }).catch(() => null),
+                    ]);
+                    return { ...p, ...parseProperty(batch), activeNow: realtime ? parseRealtime(realtime) : null };
+                }
+                catch (e) {
+                    return { ...p, error: String(e?.message || e).slice(0, 160) };
+                }
+            });
+        }
+        const properties = accounts.reduce((n, a) => n + a.properties.length, 0);
+        return { name: "Google Analytics", accounts, properties };
+    };
+    const refreshFn = async (plugin) => {
+        const cfg = (plugin.config || {});
+        if (!cfg.clientId || !cfg.clientSecret || !cfg.refreshToken) {
+            await plugin.send({ error: "ga4 plugin needs clientId, clientSecret and refreshToken" });
+            return;
+        }
+        try {
+            await plugin.send(await collect(cfg));
+        }
+        catch (e) {
+            await plugin.send({
+                error: String(e?.message || e).slice(0, 160),
+                ...(e?.code === "invalid_grant" ? { authExpired: true } : {}),
+            });
+        }
+    };
+    const monitorFn = async (plugin) => {
+        await refreshFn(plugin);
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 900000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("ga4", "ga4", "Google Analytics 4 overview (active now, users, sessions and views per property)", async () => { }, monitorFn, refreshFn, teardownFn);
+}
+export default createGa4Plugin;

package/dist/plugins/monitoring/WebsitePlugin.js

@@ -130,7 +130,7 @@ export function createWebsitePlugin() {
         try {
             const ctrl = new AbortController();
             const t = ep.timeout ? setTimeout(() => ctrl.abort(), ep.timeout) : null;
-            const res = await fetch(ep.url, { signal: ctrl.signal, redirect: "follow" });
+            const res = await fetch(ep.url, { signal: ctrl.signal, redirect: "follow", headers: ep.headers });
             if (t)
                 clearTimeout(t);
             const body = await res.text();
@@ -180,6 +180,7 @@ export function createWebsitePlugin() {
                     unexpectedStrings: cfg.unexpectedStrings,
                     expectedStatusCode: cfg.expectedStatusCode,
                     timeout: cfg.timeout,
+                    headers: cfg.headers,
                     origin: cfg.origin,
                 }];
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemonitor/plugins",
-  "version": "1.1.31",
+  "version": "1.1.33",
   "description": "daemonitor plugins",
   "types": "types/index.d.ts",
   "main": "dist/index.js",