Quantity mismatch: adding items to envelope

[elramen]

When adding managed items to a managed envelope, there are several mismatches that can occur.

Example - adding an event-creating attachment:

1. Envelope will have Error:1 more than the item.
2. Idea: Simply offset records by Error:1. But this leads to the following mismatches:
   1. Error:1 too much when there is also an event item added.
   2. Error:1 too much when there is also another event category, e.g. transaction, added before the attachment
   3. Transaction:1 too little when there is also another event category, e.g. transaction, added after the attachment

Root causes:

1. EnvelopeSummary only has 1 event_category, and its quantities implementation adds 1 extra count for the event_category - there is a race condition when multiple items added are event_category-creating.
2. An error-creating attachment has a zero error quantity as a standalone item.
3. EnvelopeSummary does not count the total number of error items - an envelope will at most have Error:1.

Draft PR: #5919

[linear-code]

RELAY-238

[elramen]

Test suite that can be used:

    pub fn managed_items_to_envelope(
        items: Managed<Items>,
        meta: RequestMeta,
        event_id: EventId,
    ) -> Managed<Box<Envelope>> {
        items.map(|items, records| {
            Box::new(Envelope::from_request(Some(event_id), meta).with_items(items))
        })
    }

    fn managed_items_to_envelope_does_not_panic(items: Items) {
        let dsn = "https://e12d836b15bb49d7bbf99e64295d995b:@sentry.io/42"
            .parse()
            .unwrap();
        let meta = RequestMeta::new(dsn);
        let (managed, _handle) = Managed::for_test(items).build();
        let envelope = managed_items_to_envelope(managed, meta, EventId::new());
        envelope.accept(|_| ());
    }

    #[test]
    fn test_managed_items_to_envelope_with_plain_attachment() {
        let mut item = Item::new(ItemType::Attachment);
        item.set_attachment_type(AttachmentType::Attachment);
        managed_items_to_envelope_does_not_panic(smallvec![item]);
    }

    #[test]
    fn test_managed_items_to_envelope_with_event_creating_attachment() {
        let mut item = Item::new(ItemType::Attachment);
        item.set_attachment_type(AttachmentType::Minidump);
        managed_items_to_envelope_does_not_panic(smallvec![item]);
    }

    #[test]
    fn test_managed_items_to_envelope_with_event() {
        managed_items_to_envelope_does_not_panic(smallvec![Item::new(ItemType::Event)]);
    }

    #[test]
    fn test_managed_items_to_envelope_with_event_and_event_creating_attachment() {
        let mut attachment = Item::new(ItemType::Attachment);
        attachment.set_attachment_type(AttachmentType::Minidump);
        let items = smallvec![Item::new(ItemType::Event), attachment];
        managed_items_to_envelope_does_not_panic(items);
    }

    #[test]
    fn test_managed_items_to_envelope_with_transaction() {
        managed_items_to_envelope_does_not_panic(smallvec![Item::new(ItemType::Transaction)]);
    }

    #[test]
    fn test_managed_items_to_envelope_with_transaction_and_event_creating_attachment() {
        let mut attachment = Item::new(ItemType::Attachment);
        attachment.set_attachment_type(AttachmentType::Minidump);
        let items = smallvec![Item::new(ItemType::Transaction), attachment];
        managed_items_to_envelope_does_not_panic(items);
    }

    #[test]
    fn test_managed_items_to_envelope_with_event_creating_attachment_and_transaction() {
        let mut attachment = Item::new(ItemType::Attachment);
        attachment.set_attachment_type(AttachmentType::Minidump);
        let items = smallvec![attachment, Item::new(ItemType::Transaction)];
        managed_items_to_envelope_does_not_panic(items);
    }

    #[test]
    fn test_managed_items_to_envelope_with_event_and_transaction_and_event_creating_attachment() {
        let mut attachment = Item::new(ItemType::Attachment);
        attachment.set_attachment_type(AttachmentType::Minidump);
        let items = smallvec![
            Item::new(ItemType::Event),
            Item::new(ItemType::Transaction),
            attachment,
        ];
        managed_items_to_envelope_does_not_panic(items);
    }

    #[test]
    fn test_managed_items_to_envelope_with_transaction_and_event_and_event_creating_attachment() {
        let mut attachment = Item::new(ItemType::Attachment);
        attachment.set_attachment_type(AttachmentType::Minidump);
        let items = smallvec![
            Item::new(ItemType::Transaction),
            Item::new(ItemType::Event),
            attachment,
        ];
        managed_items_to_envelope_does_not_panic(items);
    }

    #[test]
    fn test_managed_items_to_envelope_with_event_creating_attachment_and_transaction_and_event() {
        let mut attachment = Item::new(ItemType::Attachment);
        attachment.set_attachment_type(AttachmentType::Minidump);
        let items = smallvec![
            attachment,
            Item::new(ItemType::Transaction),
            Item::new(ItemType::Event),
        ];
        managed_items_to_envelope_does_not_panic(items);
    }