@oneuptime/common 12.0.23 → 12.0.25

package/Server/Views/Partials/AnalyticsConsent.ejs

@@ -33,21 +33,24 @@
 <!--
     Consent.
 
-    This block runs BEFORE Google Tag Manager and before PostHog, because both
-    of the things it does are only meaningful ahead of them: Consent Mode's
-    defaults have to be on the dataLayer before the container reads it, and
-    PostHog must not be loaded at all until there is consent to load it.
-
-    Three states, not two. `granted` and `denied` are the visitor's explicit
-    choices; `unset` is the state before they have answered, and it is treated
-    as denied for storage purposes rather than as permission-by-silence.
-
-    What that costs, stated plainly: a visitor who never touches the banner is
-    not measured, and their attribution is not stored. What stops that from
-    losing an ad click outright is the pending-attribution buffer further
-    down — attribution seen on this page is held in memory and written the
-    moment consent is granted, so accepting the banner on the landing page
-    keeps everything the click carried.
+    This block runs BEFORE Google Tag Manager, because Consent Mode's defaults
+    have to be on the dataLayer before the container reads it.
+
+    MEASUREMENT IS NO LONGER GATED ON THE BANNER. Consent Mode defaults to
+    granted, attribution is captured and stored on every visit, and PostHog
+    loads on every visit. The `cookiesAccepted` key is still written and
+    `oneUptimeConsent` still reports it, because the banner and the footer's
+    cookie-settings link still read and write it — but nothing downstream
+    branches on the answer any more.
+
+    Stated plainly so nobody has to infer it from the code: pressing "Reject
+    all" does not stop measurement, does not stop attribution being stored, and
+    does not clear what an earlier visit stored. This was a deliberate product
+    decision (the booking receiver needs every booking attributed, and a
+    booking is itself a deliberate act by the visitor); it is not an oversight,
+    and it is not the behaviour the banner's own copy describes. If that copy
+    or the banner UI is meant to keep promising a choice, this is the file that
+    has to change back.
 -->
 <% if(typeof enableGoogleTagManager !== 'undefined' ? enableGoogleTagManager : false){ %>
 <!--
@@ -69,7 +72,6 @@
 <script>
     window.oneUptimeConsent = (function () {
         var STORAGE_KEY = 'cookiesAccepted';
-        var listeners = [];
 
         function readRaw() {
             try {
@@ -95,19 +97,15 @@
         }
 
         /*
-         * Consent Mode v2. `security_storage` is granted because it covers
-         * things like fraud prevention that are not analytics; everything that
-         * feeds advertising or measurement starts denied.
+         * Consent Mode v2, defaulting to granted across the board.
          *
-         * wait_for_update gives the container half a second to see an update
-         * before it decides how to behave, which is what makes a visitor who
-         * accepts immediately still count.
+         * wait_for_update is kept at 500ms so the container's own timing is
+         * unchanged, even though nothing arrives later to change the answer.
          */
         function pushConsentSignal(mode, granted) {
             /*
              * No tag, nothing to tell. On a self-hosted install gtag is never
-             * defined, and consent is still tracked — it gates the attribution
-             * capture and PostHog either way.
+             * defined; the banner's answer is still recorded either way.
              */
             if (typeof window.gtag !== 'function') {
                 return;
@@ -125,12 +123,7 @@
             });
         }
 
-        pushConsentSignal('default', false);
-
-        // An earlier visit already answered: tell Google before the tag loads.
-        if (isGranted()) {
-            pushConsentSignal('update', true);
-        }
+        pushConsentSignal('default', true);
 
         function set(granted) {
             try {
@@ -139,27 +132,24 @@
                 // Nothing to persist to. The in-page decision still applies.
             }
 
-            pushConsentSignal('update', granted);
-
-            for (var i = 0; i < listeners.length; i++) {
-                try {
-                    listeners[i](granted);
-                } catch (e) {
-                    // One bad listener must not stop the others.
-                }
-            }
+            /*
+             * Deliberately NOT pushing a Consent Mode update here. The default
+             * is granted and stays granted; pushing 'denied' on a refusal would
+             * re-gate the Google tag and make the banner functional again,
+             * which is exactly what this file no longer does.
+             *
+             * There is no observer list either. Nothing downstream reacts to
+             * the answer any more, and an onChange() that could never fire is
+             * an API that reads as working code — re-add it alongside the
+             * consumer that needs it, not before.
+             */
         }
 
         return {
             state: state,
             isGranted: isGranted,
             grant: function () { set(true); },
-            deny: function () { set(false); },
-            onChange: function (listener) {
-                if (typeof listener === 'function') {
-                    listeners.push(listener);
-                }
-            }
+            deny: function () { set(false); }
         };
     })();
 </script>
@@ -182,19 +172,36 @@
 
     CONSENT
 
-    Nothing is written without consent. Attribution seen before the visitor has
-    answered the banner is held in memory and flushed if they accept, so the
-    ordinary case — land on an ad, accept, sign up — keeps everything. An
-    explicit refusal clears anything a previous visit stored.
+    None. Every touch is stored on sight, whatever the banner says and whether
+    or not it has been answered. See the block at the top of this file for why.
+
+    CAL.COM BOOKINGS
+
+    window.oneUptimeCalAttributionMetadata(bookingKind) flattens the same
+    attribution into the scalar string map Cal.com accepts as booking metadata.
+    Cal hands it back on its BOOKING_CREATED webhook, which is delivered to the
+    CRM — not to OneUptime, which receives no booking webhook at all
+    (Docs/analytics/enterprise-conversion-tracking.md).
 -->
 <script>
     (function () {
+        /*
+         * Must stay in step with UtmWireKeyToPropertyKey in
+         * Common/Types/Marketing/Attribution.ts — the signup door whitelists on
+         * that map, so a key written here that is missing there is silently
+         * dropped on arrival. AttributionCapture.test.ts asserts the two are
+         * identical.
+         */
         var UTM_KEY_MAP = {
             'utm_source': 'utmSource',
             'utm_medium': 'utmMedium',
             'utm_campaign': 'utmCampaign',
             'utm_term': 'utmTerm',
-            'utm_content': 'utmContent'
+            'utm_content': 'utmContent',
+            'utm_id': 'utmId',
+            'utm_source_platform': 'utmSourcePlatform',
+            'utm_creative_format': 'utmCreativeFormat',
+            'utm_marketing_tactic': 'utmMarketingTactic'
         };
 
         /*
@@ -208,12 +215,26 @@
         // Mirrors MaxAttributionValueLength on the server.
         var MAX_VALUE_LENGTH = 500;
 
-        // Attribution seen on this page but not yet allowed to be stored.
-        var pending = null;
+        /*
+         * The first touch travels to Cal as one JSON string, so it gets a JSON
+         * bound rather than the 500-char per-value one. Truncating JSON
+         * produces a string the receiver's JSON.parse rejects, which would drop
+         * the whole first touch silently.
+         */
+        var MAX_FIRST_TOUCH_LENGTH = 4000;
 
-        function canStore() {
-            return Boolean(window.oneUptimeConsent && window.oneUptimeConsent.isGranted());
-        }
+        /*
+         * This page's touch, kept in memory as well as written.
+         *
+         * Not a consent buffer — storeTouch runs unconditionally now. This is
+         * for the browser that refuses localStorage outright: private modes,
+         * "block all site data", a sandboxed iframe, enterprise storage policy.
+         * There, every setItem throws and is swallowed as best-effort, so a
+         * reader that trusted storage alone would hand Cal an empty bag for a
+         * visitor who arrived on a paid click seconds earlier — the exact
+         * failure this whole path exists to prevent.
+         */
+        var currentTouch = null;
 
         function setItem(key, value) {
             try {
@@ -312,15 +333,6 @@
             }
         }
 
-        function clearStoredAttribution() {
-            Object.keys(UTM_KEY_MAP).forEach(function (param) {
-                removeItem(UTM_KEY_MAP[param]);
-            });
-            removeItem('utmUrl');
-            removeItem('clickIds');
-            removeItem('firstTouch');
-        }
-
         function parseStoredJson(key) {
             var raw = getItem(key);
             if (!raw) { return null; }
@@ -333,42 +345,49 @@
         }
 
         /*
-         * Everything known about where this visitor came from, whether it has
-         * been written to storage yet or is still only in memory.
+         * Everything known about where this visitor came from, whether it
+         * reached storage or is only in memory.
          *
-         * The in-memory touch wins: it is this page load, and the stored copy
-         * is at best the same thing and at worst an older visit.
+         * This page's touch wins: it is this page load, and the stored copy is
+         * at best the same thing and at worst an older visit.
          */
         window.oneUptimeGetAttribution = function () {
             var utm = {};
             Object.keys(UTM_KEY_MAP).forEach(function (param) {
                 var key = UTM_KEY_MAP[param];
-                var value = (pending && pending.utmValues[key]) || getItem(key);
+                var value = (currentTouch && currentTouch.utmValues[key]) || getItem(key);
                 if (value && value !== 'null' && value !== 'undefined') {
                     utm[key] = value;
                 }
             });
 
-            var utmUrl = (pending && pending.url) || getItem('utmUrl');
+            var utmUrl = (currentTouch && currentTouch.url) || getItem('utmUrl');
             if (utmUrl) {
                 utm.utmUrl = utmUrl;
             }
 
-            var clickIds = (pending && pending.hasClickId ? pending.clickIds : null) || parseStoredJson('clickIds') || {};
+            var clickIds = (currentTouch && currentTouch.hasClickId ? currentTouch.clickIds : null)
+                || parseStoredJson('clickIds')
+                || {};
 
             var firstTouch = parseStoredJson('firstTouch');
 
-            if (!firstTouch && pending) {
+            /*
+             * Storage refused the write, so there is no stored first touch to
+             * read back. This visit is the only one we will ever know about,
+             * which makes it the first one.
+             */
+            if (!firstTouch && currentTouch) {
                 firstTouch = {};
-                Object.keys(pending.utmValues).forEach(function (key) {
-                    firstTouch[key] = pending.utmValues[key];
+                Object.keys(currentTouch.utmValues).forEach(function (key) {
+                    firstTouch[key] = currentTouch.utmValues[key];
                 });
-                if (pending.hasClickId) {
-                    firstTouch.clickIds = pending.clickIds;
+                if (currentTouch.hasClickId) {
+                    firstTouch.clickIds = currentTouch.clickIds;
                 }
-                firstTouch.landingUrl = pending.url;
-                firstTouch.referrer = pending.referrer;
-                firstTouch.timestamp = pending.timestamp;
+                firstTouch.landingUrl = currentTouch.url;
+                firstTouch.referrer = currentTouch.referrer;
+                firstTouch.timestamp = currentTouch.timestamp;
             }
 
             return {
@@ -378,34 +397,72 @@
             };
         };
 
-        var touch = readTouchFromUrl();
+        /*
+         * The same attribution, flattened into the scalar string map Cal.com
+         * accepts as booking metadata.
+         *
+         * Cal takes booking metadata as FLAT, BRACKETED keys on the embed
+         * config — `metadata[utm_source]` — and hands them back on the webhook
+         * as payload.metadata.utm_source. NOT as a nested `metadata: {...}`
+         * object: Cal serialises each config value into a query parameter, so a
+         * nested object becomes the string "[object Object]" and every key
+         * inside it is lost. Nothing errors; bookings keep succeeding, they
+         * just arrive attributable to nothing — indistinguishable from not
+         * having done this at all.
+         *
+         * https://cal.com/help/embedding/prefill-booking-form-embed
+         *
+         * Keys are the snake_case wire spelling, which is what the CRM's Cal
+         * webhook receiver parses. Returns {} when there is nothing to
+         * attribute and no booking kind, so a caller can spread it
+         * unconditionally without sending an empty metadata bag.
+         */
+        window.oneUptimeCalAttributionMetadata = function (bookingKind) {
+            var attribution = window.oneUptimeGetAttribution();
+            var config = {};
 
-        if (touch) {
-            if (canStore()) {
-                storeTouch(touch);
-            } else {
-                /*
-                 * Held, not dropped. A visitor who accepts the banner on this
-                 * very page — the ordinary path for someone arriving from an
-                 * ad — keeps the click id that brought them here.
-                 */
-                pending = touch;
+            function put(key, value, maxLength) {
+                if (value) {
+                    config['metadata[' + key + ']'] =
+                        String(value).slice(0, maxLength || MAX_VALUE_LENGTH);
+                }
             }
-        }
 
-        if (window.oneUptimeConsent) {
-            window.oneUptimeConsent.onChange(function (granted) {
-                if (granted) {
-                    if (pending) {
-                        storeTouch(pending);
-                    }
-                    return;
-                }
+            Object.keys(UTM_KEY_MAP).forEach(function (param) {
+                put(param, attribution.utm[UTM_KEY_MAP[param]]);
+            });
 
-                // Refused: forget what earlier visits stored, and this page's touch.
-                pending = null;
-                clearStoredAttribution();
+            put('utm_url', attribution.utm.utmUrl);
+
+            Object.keys(attribution.clickIds).forEach(function (param) {
+                put(param, attribution.clickIds[param]);
             });
+
+            if (attribution.firstTouch) {
+                var serialized = JSON.stringify(attribution.firstTouch);
+                if (serialized.length <= MAX_FIRST_TOUCH_LENGTH) {
+                    put('ou_first_touch', serialized, MAX_FIRST_TOUCH_LENGTH);
+                }
+            }
+
+            /*
+             * Unconditional, unlike everything above it. All three embeds book
+             * the same Cal event type (oneuptimehq/demo), so without this the
+             * receiver cannot tell a support call from an enterprise demo from
+             * a self-hosted architecture assessment — they arrive identical.
+             */
+            if (bookingKind) {
+                config['metadata[ou_booking_kind]'] = String(bookingKind).slice(0, MAX_VALUE_LENGTH);
+            }
+
+            return config;
+        };
+
+        var touch = readTouchFromUrl();
+
+        if (touch) {
+            currentTouch = touch;
+            storeTouch(touch);
         }
 
         /*

package/Server/Views/Partials/Head.ejs

@@ -111,7 +111,8 @@
     "sameAs": [
         "https://www.facebook.com/oneuptimeinc",
         "https://twitter.com/OneUptimeInc",
-        "https://www.linkedin.com/company/oneuptime"
+        "https://www.linkedin.com/company/oneuptime",
+        "https://njump.me/npub1kggtaw83q0mctlwvh854xdu3wjmen8tmq9cx9l030x2ylay6wk8qy2f2e6"
     ],
     "description": "OneUptime monitors websites, API's, and servers and alerts your team if something goes wrong. It also keeps your customers updated about any downtime."
 }