Add named observers

[tigerplush]

What problem does this solve or what need does it fill?

Right now, when adding observers, they show up in the egui-inspector as Observer (1v1), Observer (2v1) etc.

With a large project, this can become quite cumbersome to read and understand, so I propose adding the ability to add names to observers.

What solution would you like?

Right now, you add observers with app.add_observer(observer);, with no possiblity to specify different things.
I propose to add with_name(self, name: impl Into<String>) for IntoObserverSystem<E, B, M>, much like run_if<M>(self, condition: impl Condition<M>) has been implemented for IntoScheduleConfigs<ScheduleSystem, M>.

The final new api could look like this:
app.add_observer(observer.with_name("Custom Observer"));

What alternative(s) have you considered?

None. While it is possible, to query for Observers, it is not possible to find out where they came from once they've been spawned, so while I could add a Name component after they've been spawned, I cannot know which one.

[edit]
@notmd mentioned, you could do app.world_mut().add_observer(some_observer).insert(Name::new("Some observer"));, so for my project I'm going to write a function add_named_observer, which will be good enough for me.

Additional context

I think this has been discussed in #16384, but was closed when the inspector added a default name for Observers.

[notmd]

You already can, it just more verbose

app.world_mut().add_observer(some_observer).insert(Name::new("Some observer"));

[AlexAegis]

Could the observer fn have a require attribute like components do? Would be a lot more versatile, like for marker components.

#[require(Name::new("FooObserver"))]
fn observer(trigger: Trigger<Foo>) {}

[extrawurst]

I recently built these two helpers for this exact problem:

#[macro_export]
macro_rules! global_observer {
    ($app:expr,$system:expr) => {{
        $app.world_mut()
            .add_observer($system)
            .insert(Name::new(stringify!($system)))
    }};
}

pub fn plugin(app: &mut App) {
    global_observer!(app, on_trigger_gun);
}

this will automatically give the observer the same name in hierarchy that the system has.

Secondly I have this system that will just parent every global non-parented Observer into a single Observers Parent:

fn global_observers(
    mut cmds: Commands,
    query: Query<Entity, (With<Observer>, Without<Parent>, Added<Observer>)>,
    mut root: Local<Option<Entity>>,
) {
    if root.is_none() {
        let new_root = cmds.spawn(Name::new("Observers")).id();
        *root = Some(new_root);
    }

    let Some(root) = *root else {
        return;
    };

    for o in query.iter() {
        cmds.entity(root).add_child(o);
    }
}

[cart]

This would be inherently solved by moving to a component-driven API (the current system uses components, but spawning observers directly currently involves more work than necessary when they target a given entity). Given that we plan to go that route, I think we should just wait. Then we can just do this:

world.spawn(
  Thing,
  observers![
    (Observer::new(...), Name::new("Thing Observer"))
  ]
)

[cart]

Also for global observers you can already do this, as app.add_observer is just sugar for spawning an entity with an observer component:

world.spawn((Observer::new(...), Name::new("Thing Observer"))

[tigerplush]

For .add_observer, the solution is almost trivial.

For .observe it's a little more verbose because you need to add a target and can only spawn on Commands or RelatedSpawnerCommands