Object.prototype function preventing GTM from sending signals to GA4

I recently had one of my website pages stop sending GTM (Google Tag Manager) triggers to GA4. I tested the webpage with GTM and everything was triggering fine, but the signals weren't making it through to GA4. This webpage had already been working for months, so I couldn't figure out what the issue was.

Finally after a lot of digging I found that I had added an Object.prototype function into one of my JS scripts (e.g. "Object.prototype.abc = function()"). This prototype function seemed to be preventing communication between GTM and GA4. I'm not sure how this is even possible as the script was after any GA4 and GTM scripts and also wasn't running on anything analytics or tags related. Upon further testing I found that Number.prototype, String.prototype, and Boolean.prototype functions worked just fine but, for whatever reason, Object.prototype functions prevent GTM from sending signals to GA4. I can get around this issue by using a standard function (e.g. "function abc()"), but the prototype method is often more easy to work with and more efficient. To be clear, it's not anything in the function that is causing the issue as simply changing the prototype function to a standard function resolved the issue.

I'm just curious why this is, whether it's a bug, and if there's anyway to get around it while still using the Object.prototype method (without just using a standard function).

Solution

I’ve personally faced the exact same problem with Google Analytics / GTM breaking when extending Object.prototype.

Why it happens

The issue arises because Google Analytics (and many other third-party libraries) iterate over objects using for…in loops or similar enumeration techniques. If you add a property to Object.prototype, it becomes enumerable on all objects, which can break this iteration logic.

For example:

Object.prototype.customMethod = function() {
  console.log("This should not appear in GA objects!");
};

// GA or library code (simplified example)
const gaData = { event: "pageview", value: 42 };

for (let key in gaData) {
  console.log(key); // Logs: "event", "value", AND "customMethod" !
  // GA code expects only its own keys ("event" and "value")
  // If GA does not filter with hasOwnProperty(), this extra key can break its logic
}

In this scenario, GA encounters the unexpected customMethod property while iterating its internal objects. Since GA’s minified code often does not filter with hasOwnProperty(), it may misinterpret this property as part of its own data, causing event tracking to fail.

I confirmed this by inspecting the GA script: it indeed uses object enumeration in several places where your prototype extension leaks in, which explains why my GA events suddenly stopped being delivered.

Warnings from the web

Google JavaScript Style Guide forbids modifying built-in prototypes:

“Never modify builtin types, either by adding methods to their constructors or to their prototypes. Avoid depending on libraries that do this.”
The StackOverflow thread “Stopping enumeration in JavaScript when using prototype …” has statements along the lines of:

“In general, using a for ... in loop to iterate through an array is bad practice… In general, you should not mess with the prototypes of native Objects. This leads to problems — especially in combination with extern code/libraries.”

How to fix it

The safest solution is: don’t extend Object.prototype at all. Instead, use normal utility functions or create a helper object/module. For example:

// ❌ risky
Object.prototype.onClick = function (listener) {
  this.addEventListener("click", listener);
};

// ✅ safe
function onClick(element, listener) {
  element.addEventListener("click", listener);
}

Or if you really want to attach methods, extend only specific prototypes like Element.prototype (though even that can be risky), but never Object.prototype.

Alternative (less safe, but possible)

If you insist on defining something on Object.prototype, you can at least do it in a way that doesn’t pollute for…in loops or conflict with other code.
That means using Object.defineProperty with enumerable: false:

Object.defineProperty(Object.prototype, "onClick", {
  value: function (listener) {
    this.addEventListener("click", listener);
  },
  writable: true,
  configurable: true,
  enumerable: false // hides from for...in loops
});