fix: do not remove links for just-created Tasks

[KowalskiThomas]

What does this PR do?

This PR fixes a race condition happening around linking Parent and Children Tasks when using utilities like asyncio.gather or asyncio.as_completed.

The problem

The race condition would manifest in the following way

1. User calls e.g. asyncio.as_completed from parent_task
2. Our patch creates Tasks for each awaitable passed to the function and inserts resulting Task objects into the Task Links Map (one of each is new_task)
3. A Sample is taken exactly at that moment, Task Link Map cleanup logic kicks in.
   a. new_task was created only just now, so was not part of the all_tasks MirrorSet snapshotted by the Sampler
   b. The cleanup logic sees that there's a link from new_task to parent_task but new_task isn't in all_tasks
   c. The cleanup logic assumes that means new_task previously existed but has completed, deduces the link must be removed
   d. Link is removed
4. new_task starts executing, but isn't linked to parent_task because we've cleaned it up before it got a chance to start

Proposed fix

The fix I propose is to introduce a new previous_task_objects set which contains the addresses of all existing Task objects at the time we previously sampled.
If we see a Task object in the Task Links Map that doesn't exist in all_tasks, then two things are possible: either the Task used to exist and the link should be removed, or the Task was just created and the link should stay. To determine which case we're in, we look at previous_task_objects – if the Task is there then it previously existed and just completed (⇒ need to remove); if not, it was just created (⇒ shouldn't remove).

Admitted caveat

I think this comes with one caveat: if we sample very rarely (which may happen in certain circumstances with adaptive sampling), then we could miss certain Tasks and never get rid of their links:

async def super_quick():
  return None

async def parent():
  await asyncio.sleep(1.0)
  asyncio.gather(asyncio.create_task(super_quick()))

Given that super_quick will be… super quick, the following could happen:

• We sample; we see parent ; all_tasks = { parent }; task_links = {} ; previous_all_tasks = { parent }
• Parent continues, calls asyncio.gather(...) creates another Task ; all_tasks = { parent, super_quick }; task_links = { super_quick -> parent }
• (We don’t sample yet because we rarely sample…)
• Task execution continues, super_quick runs super quickly and finishes ; all_tasks = { parent }; task_links = { super_quick -> parent }
• We sample; we see only parent (only Task in existence at that point); current all_tasks = { parent };
  • previous_all_tasks = { parent } (still from the first sample we took) and task_links = { super_quick -> parent }
  • Our “debouncing” logic considers that super_quick is a new Task [because it’s not in previous_all_tasks] and doesn’t remove the link

⇒ The link will never go away because we’ll keep repeating this (potentially adding/removing other Tasks and Links, but this specific one will stay forever)

Additional change

The PR also fixes an issue with our patch for as_completed that would crash if parent was None. I don't think this can ever happen (since as_completed is necessarily called from a Task), but better safe than sorry.

[KowalskiThomas]

This has been reviewed+approved by Taegyun in dd-trace-py (here: DataDog/dd-trace-py#15552) so I'll go ahead and merge.