Depends on how your cookie manager is integrated, but hypothetically, one way to do it would be:
- Use a Before Load Rules tag to store inbound events in an array
utag.cachedEvents = utag.cachedEvents || [];
utag.cachedEvents.push([a, JSON.stringify(b)]);
- Create a function that will run through those and re-send them
utag.sendCachedEvents = function(){
// Nothing to do if nothing is cached
if(utag.cachedEvents.length === 0) return;
// Effectively disable sending on all tags that already loaded
// There will be smarter ways of doing this!
Object.keys(utag.sender).forEach(function(tagId){
var tagObject = utag.sender[tagId];
if(tagObject.ev){
tagObject.ev_old = tagObject.ev;
tagObject.ev = {};
}
});
// For every cached event we've got
utag.cachedEvents.forEach(function(event,eventIndex,eventArray){
// Grab the original event details from the cache
var eventType = event[0];
var eventPayload = JSON.parse(event[1]);
// Flag if this is the last cached event so we can re-enable those tags
if(eventIndex == eventArray.length - 1) eventPayload.finalCachedEvent = true;
// Trigger a send for each of the events
utag[eventType](eventPayload);
});
};
- Then you'll want an After Tags extension that will fix up the mess we created of the tag event objects above:
if(b.finalCachedEvent){
Object.keys(utag.sender).forEach(function(tagId){
var tagObject = utag.sender[tagId];
if(tagObject.ev_old){
tagObject.ev = tagObject.ev_old;
}
});
}
- Then just hook the function in step #2 into the cookie consent update
So what we're doing here is first storing events as they come in in case we need to replay them later, then when we attempt to replay them we hack the existing set of loaded tags to disable sending (this is a terrible way to do it and won't work on bundled tags that are subject to consents because it'll disable them even though they didn't fire yet, there's ways to code around that but this is just a quick and dirty demo..), so that we can replay those events back through in sequence (you may wish to async/await some delays between the sends if you feel you need it) without them re-triggering any of the tags that already loaded, in theory then only firing against tags that were previously out of scope and have now come into scope. And then finally, once the last of those payloads passes through the event process and hits the After Tags extensions, we put the tags' event flags back where they were before and all future events will run against them just fine.
There's all kinds of edge cases that this doesn't accommodate, particularly if any of your global extensions have side effects, or are intended only to run once, but broadly speaking, in a simple implementation, it disables any tags that already fired, re-runs the events so far, and then re-enables everything, in a way that does what you're after..
Expand/CollapseMenu
