forked from WICG/attribution-reporting-api
-
Notifications
You must be signed in to change notification settings - Fork 0
/
index.bs
1833 lines (1519 loc) · 90 KB
/
index.bs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<pre class='metadata'>
Title: Attribution Reporting
Shortname: attribution-reporting
Level: 1
Status: CG-DRAFT
Group: wicg
Repository: WICG/attribution-reporting-api
URL: https://wicg.github.io/attribution-reporting-api
Editor: Charlie Harrison, Google Inc. https://google.com, csharrison@chromium.org
Editor: John Delaney, Google Inc. https://google.com, johnidel@chromium.org
Editor: Andrew Paseltiner, Google Inc. https://google.com, apaseltiner@chromium.org
Abstract: An API to report that an event may have been caused by another cross-site event. These reports are designed to transfer little enough data between sites that the sites can't use them to track individual users.
Markup Shorthands: markdown on
Complain About: accidental-2119 on, missing-example-ids on
Assume Explicit For: on
</pre>
<pre class=link-defaults>
spec:html; type:element; text:a
spec:html; type:element; text:script
</pre>
<pre class="anchors">
spec: uuid; type: dfn; urlPrefix: https://wicg.github.io/uuid/
text: generate a random UUID; url: #dfn-generate-a-random-uuid
</pre>
Introduction {#intro}
=====================
<em>This section is non-normative</em>
This specification describes how web browsers can provide a mechanism to the
web that supports measuring and attributing conversions (e.g. purchases) to ads
a user interacted with on another site. This mechanism should remove one need
for cross-site identifiers like third-party cookies.
## Overview ## {#overview}
Pages/embedded sites are given the ability to register [=attribution sources=] and
[=attribution triggers=], which can be linked by the User Agent to generate and
send [=attribution reports=] containing information from both of those events.
A reporter `https://reporter.example` embedded on `https://source.example` is able to
measure whether an iteraction on the page lead to an action on `https://destination.example`
by registering an [=attribution source=] with [=attribution source/attribution destinations=]
of « `https://destination.example` ». Reporters are able to register sources through a variety
of surfaces, but ultimately the reporter is required to provide the User Agent with an
HTTP-response header which allows the source to be eligible for attribution.
At a later point in time, the reporter, now embedded on `https://destination.example`,
may register an [=attribution trigger=]. Reporters can register triggers by sending an
HTTP-response header containing information about the action/event that occurred. Internally,
the User Agent attempts to match the trigger to previously registered source events based on
where the sources/triggers were registered and configurations provided by the reporter.
If the User Agent is able to attribute the trigger to a source, it will generate and
send an [=attribution report=] to the reporter via an HTTP POST request at a later point
in time.
# HTML monkeypatches # {#html-monkeypatches}
<h3 id="monkeypatch-attributionsrc">API for elements</h3>
<pre class="idl">
interface mixin HTMLAttributionSrcElementUtils {
[CEReactions] attribute USVString attributionSrc;
};
HTMLAnchorElement includes HTMLAttributionSrcElementUtils;
HTMLImageElement includes HTMLAttributionSrcElementUtils;
HTMLScriptElement includes HTMLAttributionSrcElementUtils;
</pre>
Add the following <a spec=html>content attributes</a>:
: <{a}>
:: `attributionsrc` - [=URL=] for attribution registration
: <{img}>
:: `attributionsrc` - [=URL=] for attribution registration
: <{script}>
:: `attributionsrc` - [=URL=] for attribution registration
Add the following content attribute descriptions:
: <{a}>
:: The <dfn for="a" element-attr>attributionsrc</dfn> attribute is a [=string=]
representing the [=URL=] of the resource that will register an
[=attribution source=] when the <{a}> is navigated.
: <{img}>
:: The <dfn for="img" element-attr>attributionsrc</dfn> attribute is a
[=string=] representing the [=URL=] of the resource that will register an
[=attribution source=] or [=attribution trigger=] when set.
: <{script}>
:: The <dfn for="script" element-attr>attributionsrc</dfn> attribute is a
[=string=] representing the [=URL=] of the resource that will register an
[=attribution source=] or [=attribution trigger=] when set.
The IDL attribute {{HTMLAttributionSrcElementUtils/attributionSrc}}
must <a spec=html>reflect</a> the respective content attribute of the same
name.
<h3 id="monkeypatch-window-open">Window open steps</h4>
Issue: Monkeypatch `window.open()`.
# Fetch monkeypatches # {#fetch-monkeypatches}
Issue: Specify monkeypatches for source/trigger registration.
# Permissions Policy integration # {#permission-policy-integration}
This specification defines a [=policy-controlled feature=] identified by the string "<code><dfn noexport>attribution-reporting</dfn></code>". Its [=default allowlist=] is `'self'`.
Note: In the Chromium implementation the [=default allowlist=] is temporarily set to `*` to ease testing.
# Structures # {#structures}
<h3 dfn-type=dfn>Trigger state</h3>
A trigger state is a [=struct=] with the following items:
<dl dfn-for="trigger state">
: <dfn>trigger data</dfn>
:: A non-negative 64-bit integer.
: <dfn>report window</dfn>
:: A non-negative integer.
</dl>
<h3 dfn-type=dfn>Randomized source response</h3>
A randomized source response is null or a [=set=] of [=trigger states=].
<h3 id="attribution-filtering">Attribution filtering</h3>
A <dfn>filter value</dfn> is an [=ordered set=] of [=strings=].
A <dfn>filter map</dfn> is an [=ordered map=] whose [=map/key|keys=] are [=strings=] and whose
[=map/value|values=] are [=filter values=].
<h3 dfn-type=dfn>Source type</h3>
A source type is either "`navigation`" or "`event`".
<h3 dfn-type=dfn>Attribution source</h3>
An attribution source is a [=struct=] with the following items:
<dl dfn-for="attribution source">
: <dfn>source identifier</dfn>
:: A [=string=].
: <dfn>source origin</dfn>
:: An [=url/origin=].
: <dfn>event ID</dfn>
:: A non-negative 64-bit integer.
: <dfn>attribution destinations</dfn>
:: An [=ordered set=] of [=sites=].
: <dfn>reporting endpoint</dfn>
:: An [=url/origin=].
: <dfn>source type</dfn>
:: A [=source type=].
: <dfn>expiry</dfn>
:: A length of time.
: <dfn>event report window</dfn>
:: A length of time.
: <dfn>aggregatable report window</dfn>
:: A length of time.
: <dfn>priority</dfn>
:: A 64-bit integer.
: <dfn>source time</dfn>
:: A point in time.
: <dfn>number of event-level reports</dfn>
:: Number of [=event-level reports=] created for this [=attribution source=].
: <dfn>event-level attributable</dfn> (default true)
:: A [=boolean=].
: <dfn>dedup keys</dfn>
:: [=ordered set=] of [=event-level trigger configuration/dedup keys=] associated with this [=attribution source=].
: <dfn>randomized response</dfn>
:: A [=randomized source response=].
: <dfn>randomized trigger rate</dfn>
:: A number between 0 and 1 (both inclusive).
: <dfn>filter data</dfn>
:: A [=filter map=].
: <dfn>debug key</dfn>
:: Null or a non-negative 64-bit integer.
: <dfn>aggregation keys</dfn>
:: An [=ordered map=] whose [=map/key|keys=] are [=strings=] and whose [=map/value|values=] are
non-negative 128-bit integers.
: <dfn>aggregatable budget consumed</dfn>
:: A non-negative integer, total [=aggregatable contribution/value=] of all [=aggregatable contributions=] created with this [=attribution source=].
: <dfn>aggregatable dedup keys</dfn>
:: [=ordered set=] of [=attribution trigger/aggregatable dedup keys=] associated with this [=attribution source=].
: <dfn>debug reporting enabled</dfn>
:: A [=boolean=].
</dl>
<h3 dfn-type=dfn>Aggregatable trigger data</h3>
An aggregatable trigger data is a [=struct=] with the following items:
<dl dfn-for="aggregatable trigger data">
: <dfn>key piece</dfn>
:: A non-negative 128-bit integer.
: <dfn>source keys</dfn>
:: An [=ordered set=] of [=strings=].
: <dfn>filters</dfn>
:: A [=filter map=].
: <dfn>negated filters</dfn>
:: A [=filter map=].
</dl>
<h3 dfn-type=dfn>Event-level trigger configuration</h3>
An event-level trigger configuration is a [=struct=] with the following items:
<dl dfn-for="event-level trigger configuration">
: <dfn>trigger data</dfn>
:: A non-negative 64-bit integer.
: <dfn>dedup key</dfn>
:: Null or a non-negative 64-bit integer.
: <dfn>priority</dfn>
:: A 64-bit integer.
: <dfn>filters</dfn>
:: A [=filter map=].
: <dfn>negated filters</dfn>
:: A [=filter map=].
</dl>
<h3 dfn-type=dfn>Attribution trigger</h3>
An attribution trigger is a [=struct=] with the following items:
<dl dfn-for="attribution trigger">
: <dfn>attribution destination</dfn>
:: A [=site=].
: <dfn>trigger time</dfn>
:: A point in time.
: <dfn>reporting endpoint</dfn>
:: An [=url/origin=].
: <dfn>filters</dfn>
:: A [=filter map=].
: <dfn>negated filters</dfn>
:: A [=filter map=].
: <dfn>debug key</dfn>
:: Null or a non-negative 64-bit integer.
: <dfn>event-level trigger configurations</dfn>
:: A [=set=] of [=event-level trigger configuration=].
: <dfn>aggregatable trigger data</dfn>
:: A [=list=] of [=aggregatable trigger data=].
: <dfn>aggregatable values</dfn>
:: An [=ordered map=] whose [=map/key|keys=] are [=strings=] and whose
[=map/value|values=] are non-negative 32-bit integers.
: <dfn>aggregatable dedup key</dfn>
:: Null or a non-negative 64-bit integer.
: <dfn>serialized private state token</dfn>
:: A [=byte sequence=].
</dl>
<h3 dfn-type=dfn>Attribution report</h3>
An attribution report is a [=struct=] with the following items:
<dl dfn-for="attribution report, aggregatable report, event-level report">
: <dfn>reporting endpoint</dfn>
:: An [=url/origin=].
: <dfn>report time</dfn>
:: A point in time.
: <dfn>delivered</dfn> (default false)
:: A [=boolean=].
: <dfn>report ID</dfn>
:: A [=string=].
: <dfn>source debug key</dfn>
:: Null or a non-negative 64-bit integer.
: <dfn>trigger debug key</dfn>
:: Null or a non-negative 64-bit integer.
</dl>
<h3 dfn-type=dfn>Event-level report</h3>
An event-level report is an [=attribution report=] with the following additional items:
<dl dfn-for="event-level report">
: <dfn>event ID</dfn>
:: A non-negative 64-bit integer.
: <dfn>source type</dfn>
:: A [=source type=].
: <dfn>trigger data</dfn>
:: A non-negative 64-bit integer.
: <dfn>randomized trigger rate</dfn>
:: A number between 0 and 1 (both inclusive).
: <dfn>trigger priority</dfn>
:: A 64-bit integer.
: <dfn>trigger time</dfn>
:: A point in time.
: <dfn>source identifier</dfn>
:: A string.
: <dfn>attribution destinations</dfn>
:: An [=ordered set =] of [=sites=].
</dl>
<h3 dfn-type=dfn>Aggregatable contribution</h3>
An aggregatable contribution is a [=struct=] with the following items:
<dl dfn-for="aggregatable contribution">
: <dfn>key</dfn>
:: A non-negative 128-bit integer.
: <dfn>value</dfn>
:: A non-negative 32-bit integer.
</dl>
<h3 dfn-type=dfn>Aggregatable report</h3>
An aggregatable report is an [=attribution report=] with the following additional items:
<dl dfn-for="aggregatable report">
: <dfn>source time</dfn>
:: A point in time.
: <dfn>original report time</dfn>
:: A point in time.
: <dfn>contributions</dfn>
:: A [=list=] of [=aggregatable contributions=].
: <dfn>effective attribution destination</dfn>
:: A [=site=].
: <dfn>serialized private state token</dfn>
:: A [=byte sequence=].
</dl>
Issue: Use [=aggregatable report/delivered=] in [=queue a report for delivery=].
<h3 dfn-type=dfn>Attribution rate-limit record</h3>
An attribution rate-limit record is a [=struct=] with the following items:
<dl dfn-for="attribution rate-limit record">
: <dfn>scope</dfn>
:: Either "`source`" or "`attribution`".
: <dfn>source site</dfn>
:: A [=site=].
: <dfn>attribution destination</dfn>
:: A [=site=].
: <dfn>reporting endpoint</dfn>
:: An [=url/origin=].
: <dfn>time</dfn>
:: A point in time.
:: <dfn>expiry time</dfn>
:: Null or a point in time.
</dl>
<h3 dfn-type=dfn>Attribution debug data</h3>
A <dfn>debug data type</dfn> is a non-empty string that specifies the set of data that is
contained in the [=attribution debug data/body=] of an [=attribution debug data=].
A <dfn>source debug data type</dfn> is a [=debug data type=] for source registrations.
Possible values are:
<ul>
<li>"`source-destination-limit`"</li>
<li>"`source-noised`"</li>
<li>"`source-storage-limit`"</li>
<li>"`source-unknown-error`"</li>
</ul>
An attribution debug data is a [=struct=] with the following items:
<dl dfn-for="attribution debug data">
: <dfn>data type</dfn>
:: A [=debug data type=].
: <dfn>body</dfn>
:: A [=map=] whose fields are determined by the [=attribution debug data/data type=].
</dl>
<h3 dfn-type=dfn>Attribution debug report</h3>
An attribution debug report is a [=struct=] with the following items:
<dl dfn-for="attribution debug report">
: <dfn>data</dfn>
:: A [=list=] of [=attribution debug data=].
: <dfn>reporting endpoint</dfn>
:: An [=origin=].
</dl>
# Storage # {#storage}
A user agent holds an <dfn>attribution source cache</dfn>, which is an [=ordered set=] of [=attribution sources=].
A user agent holds an <dfn>event-level report cache</dfn>, which is an [=ordered set=] of [=event-level reports=].
A user agent holds an <dfn>aggregatable report cache</dfn>, which is an [=ordered set=] of [=aggregatable reports=].
A user agent holds an <dfn>attribution rate-limit cache</dfn>, which is an [=ordered set=] of [=attribution rate-limit records=].
The above caches are collectively known as the <dfn>attribution caches</dfn>. The [=attribution caches=] are
shared among all [=environment settings objects=].
Note: This would ideally use <a spec=storage>storage bottles</a> to provide access to the attribution caches.
However attribution data is inherently cross-site, and operations on storage would need to span across all storage bottle maps.
# Vendor-Specific Values # {#vendor-specific-values}
<dfn>Source event ID cardinality</dfn> is a positive integer that controls the
maximum value that can be used as an [=attribution source/event id=].
<dfn>Max source expiry</dfn> is a positive length of time that controls the
maximum value that can be used as an [=attribution source/expiry=]. It must be
greater than or equal to 30 days.
<dfn>Max entries per filter map</dfn> is a positive integer that controls the
maximum [=map/size=] of a [=filter map=].
<dfn>Max values per filter entry</dfn> is a positive integer that
controls the maximum [=set/size=] of a [=filter map=] entry.
<dfn>Max aggregation keys per attribution</dfn> is a positive integer that
controls the maximum [=map/size=] of an [=attribution source=]'s
[=attribution source/aggregation keys=], the maximum [=set/size=] of an
[=aggregatable trigger data=]'s [=aggregatable trigger data/source keys=],
and the maximum [=map/size=] of an [=attribution trigger=]'s
[=attribution trigger/aggregatable values=].
<dfn>Max aggregatable trigger data per trigger</dfn> is a positive integer that
controls the maximum [=list/size=] of an [=attribution trigger=]'s
[=attribution trigger/aggregatable trigger data=].
<dfn>Max pending sources per source origin</dfn> is a positive integer that
controls how many [=attribution sources=] can be in the
[=attribution source cache=] per [=attribution source/source origin=].
<dfn>Navigation-source trigger data cardinality</dfn> is a positive integer
that controls the valid range of
[=event-level trigger configuration/trigger data=] for triggers that are
attributed to an [=attribution source=] whose
[=attribution source/source type=] is "`navigation`":
0 <= [=event-level trigger configuration/trigger data=] < [=navigation-source trigger data cardinality=].
<dfn>Event-source trigger data cardinality</dfn> is a positive integer that
controls the valid range of [=event-level trigger configuration/trigger data=]
for triggers that are attributed to an [=attribution source=] whose
[=attribution source/source type=] is "`event`":
0 <= [=event-level trigger configuration/trigger data=] < [=event-source trigger data cardinality=].
<dfn>Randomized navigation-source trigger rate</dfn> is a double between 0 and
1 (both inclusive) that controls the randomized response probability of an
[=attribution source=] whose [=attribution source/source type=] is
"`navigation`".
<dfn>Randomized event-source trigger rate</dfn> is a double between 0 and 1
(both inclusive) that controls the randomized response probability of an
[=attribution source=] whose [=attribution source/source type=] is "`event`".
<dfn>Max event-level reports per attribution destination</dfn> is a positive integer that
controls how many [=event-level reports=] can be in the
[=event-level report cache=] per [=site=] in
[=event-level report/attribution destinations=].
<dfn>Max aggregatable reports per attribution destination</dfn> is a positive integer that controls how
many [=aggregatable reports=] can be in the [=aggregatable report cache=] per
[=aggregatable report/effective attribution destination=].
<dfn>Max attributions per navigation source</dfn> is a positive integer that
controls how many times a single [=attribution source=] whose
[=attribution source/source type=] is "`navigation`" can create an
[=event-level report=].
<dfn>Max attributions per event source</dfn> is a positive integer that
controls how many times a single [=attribution source=] whose
[=attribution source/source type=] is "`event`" can create an
[=event-level report=].
<dfn>Max destinations covered by unexpired sources</dfn> is a positive
integer that controls the maximum number of distinct [=sites=] across all [=attribution source/attribution destinations=]
for unexpired [=attribution sources=] with a given ([=attribution source/source site=], [=attribution source/reporting endpoint=]).
<dfn>Attribution rate-limit window</dfn> is a positive length of time that
controls the rate-limiting window for attribution.
<dfn>Max source reporting endpoints per rate-limit window</dfn> is a positive
integer that controls the maximum number of distinct
[=attribution source/reporting endpoint|reporting endpoints=] for a
([=attribution rate-limit record/source site=],
[=attribution rate-limit record/attribution destination=]) that can create
[=attribution sources=] per [=attribution rate-limit window=].
<dfn>Max attribution reporting endpoints per rate-limit window</dfn> is a
positive integer that controls the maximum number of distinct
[=attribution trigger/reporting endpoint|reporting endpoints=] for a
([=attribution rate-limit record/source site=],
[=attribution rate-limit record/attribution destination=]) that can create
[=event-level reports=] per [=attribution rate-limit window=].
<dfn>Max attributions per rate-limit window</dfn> is a positive integer that
controls the maximum number of attributions for a
([=attribution rate-limit record/source site=],
[=attribution rate-limit record/attribution destination=],
[=attribution rate-limit record/reporting endpoint=]) per
[=attribution rate-limit window=].
<dfn>Max source cache size</dfn> is a positive integer that controls how many
[=attribution sources=] can be in the [=attribution source cache=].
<dfn>Max event-level report cache size</dfn> is a positive integer that controls how many
[=event-level reports=] can be in the [=event-level report cache=].
<dfn>Max aggregatable report cache size</dfn> is a positive integer that controls how many
[=aggregatable reports=] can be in the [=aggregatable report cache=].
<dfn>Allowed aggregatable budget per source</dfn> is a positive integer that controls the total
[=aggregatable report/required aggregatable budget=] of all [=aggregatable reports=] created for
an [=attribution source=].
<dfn>Min aggregatable report delay</dfn> is a non-negative length of time that controls the minimum
delay to deliver an [=aggregatable report=].
<dfn>Randomized aggregatable report delay</dfn> is a positive length of time that controls the
random delay to deliver an [=aggregatable report=].
# General Algorithms # {#general-algorithms}
<h3 id="parsing-filter-data">Parsing filter data</h3>
To <dfn>parse filter data</dfn> given a |value| and a [=string=]
<dfn for="parse filter data"><var>registrationType</var></dfn>:
1. Assert: |registrationType| is either "`source`" or "`trigger`".
1. If |value| is not a [=map=], return null.
1. If |registrationType| is "`source`" and |value|["`source_type`"]
[=map/exists=], return null.
1. If |value|'s [=map/size=] is greater than the user agent's
[=max entries per filter map=], return null.
1. Let |result| be a new [=filter map=].
1. [=map/iterate|For each=] |filter| → |data| of |value|:
1. If |data| is not a [=list=], return null.
1. Let |set| be a new [=ordered set=].
1. [=list/iterate|For each=] |d| of |data|:
1. If |d| is not a [=string=], return null.
1. [=set/Append=] |d| to |set|.
1. If |set|'s [=set/size=] is greater than the user agent's
[=max values per filter entry=], return null.
1. [=map/Set=] |result|[|filter|] to |set|.
1. Return |result|.
Issue: Determine whether to limit [=string/length=] or
[=string/code point length=] for |filter| and |d| above.
<h3 id="debug-keys">Cookie-based debugging</h3>
To <dfn>check if cookie-based debugging is allowed</dfn> given an [=origin=]
|reportingOrigin|:
1. [=Assert=]: |reportingOrigin| is a [=potentially trustworthy origin=].
1. Return <strong>blocked</strong>.
Issue: Check for "`ar_debug`" cookie on |reportingOrigin| and return
<strong>allowed</strong> if it exists, is `Secure`, is `HttpOnly`, and is
`SameSite=None`.
<h3 id="obtaining-randomized-response">Obtaining a randomized response</h3>
To <dfn>obtain a randomized response</dfn> given |trueValue|, a [=set=] |possibleValues|, and a
double |randomPickRate|:
1. [=Assert=]: |randomPickRate| is between 0 and 1 (both inclusive).
1. Let |r| be a random double between 0 (inclusive) and 1 (exclusive) with uniform probability.
1. If |r| is less than |randomPickRate|, return a random item from |possibleValues| with uniform
probability.
1. Otherwise, return |trueValue|.
<h3 algorithm id="parsing-aggregation-key-piece">Parsing aggregation key piece</h3>
To <dfn>parse an aggregation key piece</dfn> given a [=string=] |input|, perform the following steps.
This algorithm will return either a non-negative 128-bit integer or an error.
1. If |input|'s [=string/code point length=] is not between 3 and 34 (both inclusive), return an error.
1. If the first character is not a U+0030 DIGIT ZERO (0), return an error.
1. If the second character is not a U+0058 LATIN CAPITAL LETTER X character (X) and not a
U+0078 LATIN SMALL LETTER X character (x), return an error.
1. Let |value| be the [=code point substring=] from 2 to the end of |input|.
1. If the characters within |value| are not all [=ASCII hex digits=], return an error.
1. Interpret |value| as a hexadecimal number and return as a non-negative 128-bit integer.
<h3 dfn id="can-attribution-rate-limit-record-be-removed">Can attribution rate-limit record be removed</h3>
Given an [=attribution rate-limit record=] |record|:
1. If |record|'s [=attribution rate-limit record|time=] is after the current time, return false.
1. If |record|'s [=attribution rate-limit record/scope=] equals `"attribution"`, return true.
1. If |record|'s [=attribution rate-limit record/expiry time=] is after the current time, return false.
1. Return true.
<h3 id="obtaining-and-delivering-debug-report">Obtaining and delivering an attribution debug report</h3>
To <dfn>obtain and deliver a debug report</dfn> given a [=list=] of [=attribution debug data=] |data|
and an [=origin=] |reportingEndpoint|:
1. [=Assert=]: |reportingEndpoint| is a [=potentially trustworthy origin=].
1. Let |debugReport| be an [=attribution debug report=] with the items:
: [=attribution debug report/data=]
:: |data|
: [=attribution debug report/reporting endpoint=]
:: |reportingEndpoint|
1. [=Queue a task=] to [=attempt to deliver a verbose debug report=] with |debugReport|.
# Source Algorithms # {#source-algorithms}
<h3 id="obtaining-attribution-source-expiry-time">Obtaining an attribution source's expiry time</h3>
An [=attribution source=] |source|'s <dfn for="attribution source">expiry time</dfn> is |source|'s [=attribution source/source time=] + |source|'s [=attribution source/expiry=].
<h3 id="obtaining-attribution-source-event-report-window-time">Obtaining an attribution source's event report window time</h3>
An [=attribution source=] |source|'s <dfn for="attribution source">event report window time</dfn> is |source|'s [=attribution source/source time=] + |source|'s [=attribution source/event report window=].
<h3 id="obtaining-attribution-source-aggregatable-report-window-time">Obtaining an attribution source's aggregatable report window time</h3>
An [=attribution source=] |source|'s <dfn for="attribution source">aggregatable report window time</dfn> is |source|'s [=attribution source/source time=] + |source|'s [=attribution source/aggregatable report window=].
<h3 id="obtaining-attribution-source-site">Obtaining an attribution source's source site</h3>
An [=attribution source=] |source|'s <dfn for="attribution source">source site</dfn> is the result
of [=obtain a site|obtaining a site=] from |source|'s [=attribution source/source origin=].
<h3 algorithm id="parsing-attribution-destination">Parsing an attribution destination</h3>
To <dfn>parse an attribution destination</dfn> from a [=string=] |str|:
1. Let |url| be the result of running the [=URL parser=] on the value of
the |str|.
1. If |url| is failure or null, return null.
1. If |url|'s [=url/origin=] is not a [=potentially trustworthy origin=],
return null.
1. Return the result of [=obtain a site|obtaining a site=] from |url|'s
[=url/origin=].
<h3 algorithm id="parsing-attribution-destinations">Parsing attribution destinations</h3>
To <dfn>parse attribution destinations</dfn> from a value |val|:
1. Let |result| be an [=ordered set=].
1. If |val| is a [=string=], [=set/append=] the result of [=parse an attribution destination=] to |result|, and return |result|.
1. If |val| is not a [=list=], return null.
1. [=list/iterate|For each=] |value| of |val|
1. If |value| is not a [=string=], return null.
1. Let |destination| be the result of [=parse an attribution destination=] with |value|.
1. If |destination| is null, return null.
1. [=set/append=] |destination| to |result|.
1. If |result|'s [=set/size=] is greater than 3, return null.
1. If |result| is [=set/empty=], return null.
1. return |result|.
Issue: confirm that the maximum destinations size is workable.
<h3 algorithm id="obtaining-randomized-source-response">Obtaining a randomized source response</h3>
To <dfn>obtain a randomized source response</dfn> given a positive integer
|triggerDataCardinality|, a positive integer |maxAttributionsPerSource|, a positive integer
|numReportWindows|, and a double |randomPickRate|:
1. Let |possibleTriggerStates| be a new [=list/is empty|empty=] [=set=].
1. For each integer |triggerData| between 0 (inclusive) and |triggerDataCardinality| (exclusive):
1. For each integer |reportWindow| between 0 (inclusive) and |numReportWindows| (exclusive):
1. Let |state| be a new [=trigger state=] with the items:
: [=trigger state/trigger data=]
:: |triggerData|
: [=trigger state/report window=]
:: |reportWindow|
1. [=set/Append=] |state| to |possibleTriggerStates|.
1. Let |possibleValues| be a new [=list/is empty|empty=] [=set=].
1. For each integer |attributions| between 0 (inclusive) and |maxAttributionsPerSource| (inclusive):
1. [=set/Append=] to |possibleValues| all distinct |attributions|-length combinations of
|possibleTriggerStates|.
1. Return the result of [=obtaining a randomized response=] with null, |possibleValues|, and
|randomPickRate|.
<h3 algorithm id="obtaining-attribution-source-anchor">Obtaining an attribution source from an <code>a</code> element</h3>
To <dfn>obtain an attribution source from an anchor</dfn> given an <{a}> element |anchor|:
1. If |anchor| does not have an <{a/attributionsrc}> attribute, return null.
1. Return null.
Issue: Specify the steps for making attributionsrc request.
<h3 algorithm id="obtaining-attribution-source-window-features">Obtaining an attribution source from window features</h3>
To <dfn>obtain an attribution source from window features</dfn> given an [=ordered map=] |tokenizedFeatures|:
1. If |tokenizedFeatures|["attributionsrc"] does not [=map/exists|exist=], return null.
1. Let |decodedSrcBytes| be the result of [=string/percent-decode|percent-decoding=] |tokenizedFeatures|["attributionsrc"].
1. Let |decodedSrc| be the [=UTF-8 decode without BOM=] of |decodedSrcBytes|.
1. Return null.
Issue: Check for transient activation.
Issue: Specify the steps for making an attributionsrc request with |decodedSrc|.
<h3 algorithm id="parsing-source-registration">Parsing source-registration JSON</h3>
To <dfn>obtain a source expiry</dfn> given a |value|:
1. If |value| is not a [=string=], return null.
1. Let |expirySeconds| be the result of applying the
<a spec="html">rules for parsing integers</a> to |value|.
1. If |expirySeconds| is an error, return null.
1. Let |expiry| be |expirySeconds| seconds.
1. If |expiry| is less than 1 day, set |expiry| to 1 day.
1. If |expiry| is greater than the user agent's [=max source expiry=], set
|expiry| to that value.
1. Return |expiry|.
To <dfn>parse aggregation keys</dfn> given an [=ordered map=] |map|:
1. Let |aggregationKeys| be a new [=ordered map=].
1. If |map|["`aggregation_keys`"] does not [=map/exist=], return |aggregationKeys|.
1. Let |values| be |map|["`aggregation_keys`"].
1. If |values| is not an [=ordered map=], return null.
1. If |values|'s [=map/size=] is greater than the user agent's
[=max aggregation keys per attribution=], return null.
1. [=map/iterate|For each=] |key| → |value| of |values|:
1. If |value| is not a [=string=], return null.
1. Let |keyPiece| be the result of running [=parse an aggregation key piece=] with |value|.
1. If |keyPiece| is an error, return null.
1. [=map/Set=] |aggregationKeys|[|key|] to |keyPiece|.
1. Return |aggregationKeys|.
To <dfn noexport>parse source-registration JSON</dfn> given a [=string=]
|json|, an [=origin=] |sourceOrigin|, an [=origin=] |reportingOrigin|, and a
[=source type=] |sourceType|:
1. [=Assert=]: |sourceOrigin| is a [=potentially trustworthy origin=].
1. [=Assert=]: |reportingOrigin| is a [=potentially trustworthy origin=].
1. Let |value| be the result of running
[=parse a JSON string to an Infra value=] with |json|.
1. If |value| is not an [=ordered map=], return null.
1. Let |sourceEventId| be 0.
1. If |value|["`source_event_id`"] [=map/exists=] and is a [=string=]:
1. Set |sourceEventId| to the result of applying the
<a spec="html">rules for parsing non-negative integers</a> to
|value|["`source_event_id`"] modulo the user agent's
[=source event ID cardinality=].
1. If |sourceEventId| is an error, set |sourceEventId| to 0.
1. If |value|["`destination`"] does not [=map/exists|exist=], return null.
1. Let |attributionDestinations| be the result of running
[=parse attribution destinations=] with |value|["`destination`"].
1. If |attributionDestinations| is null, return null.
1. Let |expiry| be the result of running [=obtain a source expiry=] on |value|["`expiry`"].
1. If |expiry| is null, set |expiry| to 30 days.
1. Let |eventReportWindow| be the result of running [=obtain a source expiry=] on |value|["`event_report_window`"].
1. If |eventReportWindow| is null or greater than |expiry|, set |eventReportWindow| to |expiry|.
1. Let |aggregatableReportWindow| be the result of running [=obtain a source expiry=] on |value|["`aggregatable_report_window`"].
1. If |aggregatableReportWindow| is null or greater than |expiry|, set |aggregatableReportWindow| to |expiry|.
1. Let |priority| be 0.
1. If |value|["`priority`"] [=map/exists=] and is a [=string=]:
1. Set |priority| to the result of applying the
<a spec="html">rules for parsing integers</a> to |value|["`priority`"].
1. If |priority| is an error, set |priority| to 0.
1. Let |filterData| be a new [=filter map=].
1. If |value|["`filter_data`"] [=map/exists=]:
1. Set |filterData| to the result of running [=parse filter data=] with
|value|["`filter_data`"] and [=parse filter data/registrationType=] set
to "`source`".
1. If |filterData| is null, return null.
1. [=map/Set=] |filterData|["`source_type`"] to « |sourceType| ».
1. Let |debugKey| be null.
1. If |value|["`debug_key`"] [=map/exists=] and is a [=string=]:
1. Set |debugKey| to the result of applying the
<a spec="html">rules for parsing non-negative integers</a> to
|value|["`debug_key`"].
1. If |debugKey| is an error, set |debugKey| to null.
1. If the result of running [=check if cookie-based debugging is allowed=] with
|reportingOrigin| is <strong>blocked</strong>, set |debugKey| to null.
1. Let |aggregationKeys| be the result of running [=parse aggregation keys=] with |value|.
1. If |aggregationKeys| is null, return null.
1. If |aggregatableExpiry| is null, set |aggregatableExpiry| to |expiry|.
1. Let |triggerDataCardinality| be the user agent's
[=navigation-source trigger data cardinality=].
1. Let |randomizedTriggerRate| be the user agent's
[=randomized navigation-source trigger rate=].
1. Let |maxAttributionsPerSource| be the user agent's
[=max attributions per navigation source=].
1. If |sourceType| is "`event`":
1. Round |expiry| away from zero to the nearest day (86400 seconds).
1. Set |triggerDataCardinality| to the user agent's
[=event-source trigger data cardinality=].
1. Set |randomizedTriggerRate|'s to the user agent's
[=randomized event-source trigger rate=].
1. Set |maxAttributionsPerSource| to the user agent's
[=max attributions per event source=].
1. Let |numReportWindows| be the result of running
[=obtain the number of report windows=] with |sourceType|.
1. Let |debugReportingEnabled| be false.
1. If |value|["`debug_reporting`"] [=map/exists=] and is a [=boolean=], set
|debugReportingEnabled| to |value|["`debug_reporting`"].
1. Let |source| be a new [=attribution source=] struct whose items are:
: [=attribution source/source identifier=]
:: A new unique [=string=]
: [=attribution source/source origin=]
:: |sourceOrigin|
: [=attribution source/event ID=]
:: |sourceEventId|
: [=attribution source/attribution destinations=]
:: |attributionDestinations|
: [=attribution source/reporting endpoint=]
:: |reportingOrigin|
: [=attribution source/expiry=]
:: |expiry|
: [=attribution source/event report window=]
:: |eventReportWindow|
: [=attribution source/aggregatable report window=]
:: |aggregatableReportWindow|
: [=attribution source/priority=]
:: |priority|
: [=attribution source/source time=]
:: The current time
: [=attribution source/source type=]
:: |sourceType|
: [=attribution source/randomized response=]
:: The result of [=obtaining a randomized source response=] with
|triggerDataCardinality|, |maxAttributionsPerSource|,
|numReportWindows|, and |randomizedTriggerRate|.
: [=attribution source/randomized trigger rate=]
:: |randomizedTriggerRate|
: [=attribution source/filter data=]
:: |filterData|
: [=attribution source/debug key=]
:: |debugKey|
: [=attribution source/aggregation keys=]
:: |aggregationKeys|
: [=attribution source/aggregatable budget consumed=]
:: 0
: [=attribution source/debug reporting enabled=]
:: |debugReportingEnabled|
1. Return |source|.
Issue: Ensure that all sites in |attributionDestinations| have HTTP/HTTPS [=origin/schemes=].
<h3 id="check-unexpired-destination-limit">Checking unexpired destination limit</h3>
To <dfn>check if an [=attribution source=] exceeds the unexpired destination limit</dfn> given an
[=attribution source=] |source|, run the following steps:
1. Let |unexpiredSources| be all [=attribution rate-limit records=] |record| in the [=attribution rate-limit cache=] where all of the following are true:
* |record|'s [=attribution rate-limit record/scope=] equals "`source`"
* |record|'s [=attribution rate-limit record/source site=] and |source|'s [=attribution source/source site=] are equal
* |record|'s [=attribution rate-limit record/reporting endpoint=] and |source|'s [=attribution source/reporting endpoint=] are equal
* |record|'s [=attribution rate-limit record/expiry time=] is greater than |source|'s [=attribution source/source time=]
1. Let |unexpiredDestinations| be an [=set/empty=] [=set=].
1. For each [=attribution rate-limit record=] |unexpiredRecord| of |unexpiredSources|:
1. [=set/append=] |unexpiredRecord|'s [=attribution rate-limit record/attribution destination=] to |unexpiredDestinations|.
1. Let |newDestinations| be the result of taking the [=set/union=] of |unexpiredDestinations| and |source|'s [=attribution source/attribution destinations=].
1. Return whether |newDestinations|'s [=set/size=] is greater than or equal to the user agent's [=max destinations covered by unexpired sources=].
<h3 id="processing-an-attribution-source">Processing an attribution source</h3>
To <dfn>obtain a fake report</dfn> given an [=attribution source=] |source| and
a [=trigger state=] |triggerState|:
1. Let |fakeConfig| be a new [=event-level trigger configuration=] with the items:
: [=event-level trigger configuration/trigger data=]
:: |triggerState|'s [=trigger state/trigger data=]
: [=event-level trigger configuration/dedup key=]
:: null
: [=event-level trigger configuration/priority=]
:: 0
: [=event-level trigger configuration/filters=]
:: «[ "`source_type`" → « |source|'s [=attribution source/source type=] » ]»
1. Let |fakeTrigger| be a new [=attribution trigger=] with the items:
: [=attribution trigger/attribution destinations=]
:: |source|'s [=attribution source/attribution destinations=]
: [=attribution trigger/trigger time=]
:: |source|'s [=attribution source/source time=]
: [=attribution trigger/reporting endpoint=]
:: |source|'s [=attribution source/reporting endpoint=]
: [=attribution trigger/filters=]
:: «[]»
: [=attribution trigger/debug key=]
:: null
: [=attribution trigger/event-level trigger configurations=]
:: « |fakeConfig| »
: [=attribution trigger/aggregatable trigger data=]
:: «»
: [=attribution trigger/aggregatable values=]
:: «[]»
: [=attribution trigger/aggregatable dedup key=]
:: null
1. Let |fakeReport| be the result of running [=obtain an event-level report=] with |source|,
|fakeTrigger|, and |fakeConfig|.
1. Set |fakeReport|'s [=event-level report/report time=] to the result of
running [=obtain the report time at a window=] with |source| and
|triggerState|'s [=trigger state/report window=].
1. Return |fakeReport|.
To <dfn>check if debug reporting is allowed</dfn> given a [=source debug data type=] |dataType|
and an [=origin=] |reportingOrigin|:
1. If |dataType| is:
<dl class="switch">
<dt>"`source-destination-limit`"</dt>
<dd>Return <strong>allowed</strong>.</dd>
<dt>"`source-noised`"</dt>
<dt>"`source-storage-limit`"</dt>
<dt>"`source-unknown-error`"</dt>
<dd>Return the result of running [=check if cookie-based debugging is allowed=] with |reportingOrigin|.</dd>
</dl>
To <dfn>obtain and deliver a debug report on source registration</dfn> given a
[=source debug data type=] |dataType| and an [=attribution source=] |source|:
1. If |source|'s [=attribution source/debug reporting enabled=] is false, return.
1. If the result of running [=check if debug reporting is allowed=] with |dataType| and |source|'s
[=attribution source/reporting endpoint=] is <strong>blocked</strong>, return.
1. Let |body| be a new [=map=] with the following key/value pairs:
: "`attribution_destination`"
:: |source|'s [=attribution source/attribution destinations=], [=serialize attribution destinations|serialized=].
: "`source_event_id`"
:: |source|'s [=attribution source/event ID=], [=serialize an integer|serialized=].
: "`source_site`"
:: |source|'s [=attribution source/source site=], <a href="https://html.spec.whatwg.org/multipage/origin.html#serialization-of-a-site">serialized</a>.
1. If |source|'s [=attribution source/debug key=] is not null, [=map/set=] |body|["`source_debug_key`"]
to |source|'s [=attribution source/debug key=], [=serialize an integer|serialized=].
1. If |dataType| is:
<dl class="switch">
<dt>"`source-destination-limit`"</dt>
<dd>[=map/Set=] |body|["`limit`"] to the user agent's [=max destinations covered by unexpired sources=],
[=serialize an integer|serialized=].</dd>
<dt>"`source-storage-limit`"</dt>
<dd>[=map/Set=] |body|["`limit`"] to the user agent's [=max pending sources per source origin=],
[=serialize an integer|serialized=].</dd>
</dl>
1. Let |data| be a new [=attribution debug data=] with the items:
: [=attribution debug data/data type=]
:: |dataType|
: [=attribution debug data/body=]
:: |body|
1. Run [=obtain and deliver a debug report=] with « |data| » and |source|'s [=attribution source/reporting endpoint=].
To <dfn>process an attribution source</dfn> given an [=attribution source=] |source|:
1. Let |cache| be the user agent's [=attribution source cache=].
1. [=list/Remove=] all entries in |cache| where the entry's [=attribution source/expiry time=] is less than the current time.
1. If the [=list/size=] of |cache| is greater than or equal to the user agent's
[=max source cache size=], return.
1. Let |pendingSourcesForSourceOrigin| be the [=set=] of all
[=attribution sources=] |pendingSource| of |cache| where |pendingSource|'s
[=attribution source/source origin=] and |source|'s
[=attribution source/source origin=] are [=same origin=].
1. If |pendingSourcesForSourceOrigin|'s [=list/size=] is greater than or equal
to the user agent's [=max pending sources per source origin=]:
1. Run [=obtain and deliver a debug report on source registration=] with "`source-storage-limit`" and |source|.
1. Return.
1. If the result of running [=check if an attribution source exceeds the unexpired destination limit=]
with |source| is true:
1. Run [=obtain and deliver a debug report on source registration=] with "`source-destination-limit`" and |source|.
1. Return.
1. [=set/iterate|For each=] |destination| in |source|'s [=attribution source/attribution destinations=]
1. Let |rateLimitRecord| be a new [=attribution rate-limit record=] with the items:
: [=attribution rate-limit record/scope=]
:: "`source`"
: [=attribution rate-limit record/source site=]
:: |source|'s [=attribution source/source site=]
: [=attribution rate-limit record/attribution destination=]
:: |destination|
: [=attribution rate-limit record/reporting endpoint=]
:: |source|'s [=attribution source/reporting endpoint=]
: [=attribution rate-limit record/time=]
:: |source|'s [=attribution source/source time=]
: [=attribution rate-limit record/expiry time=]
:: |source|'s [=attribution source/expiry time=]
1. If the result of running [=should processing be blocked by reporting-endpoint limit=] with
|rateLimitRecord| is <strong>blocked</strong>, return.
1. [=set/Append=] |rateLimitRecord| to the [=attribution rate-limit cache=].
1. [=list/Remove=] all entries from the [=attribution rate-limit cache=] if the result of running
[=can attribution rate-limit record be removed=] with the entry is true.
1. If |source|'s [=attribution source/randomized response=] is not null and is a [=set=]:
1. [=map/iterate|For each=] [=trigger state=] |triggerState| of |source|'s
[=attribution source/randomized response=]:
1. Let |fakeReport| be the result of running [=obtain a fake report=]
with |source| and |triggerState|.
1. [=set/Append=] |fakeReport| to the [=event-level report cache=].
1. If |source|'s [=attribution source/randomized response=] is not [=set/is empty|empty=],
then set |source|'s [=attribution source/event-level attributable=] value to false.
1. Run [=obtain and deliver a debug report on source registration=] with "`source-noised`" and |source|.
1. [=set/Append=] |source| to |cache|.
Issue: Should fake reports respect the user agent's [=max event-level reports per attribution destination=]?
# Triggering Algorithms # {#trigger-algorithms}
<h3 algorithm id="attribution-trigger-creation">Creating an attribution trigger</h3>
To <dfn>parse event triggers</dfn> given an [=ordered map=] |map|: