Deprecation warnings that warn only when the deprecated call is directly "your fault"

[LilithHafner]

There should be a way to create deprecation warnings so that If I use a package that has those deprecated calls, I don't get a warning but if I write code that uses those calls (script, repl, or ]deving a package) I do get a warning.

Originally posted by @oxinabox in #47150 (comment)

[BioTurboNick]

Was actually just thinking about how to formalize a generic "your code/their code" classification, something like that used by AbbreviatedStackTraces. The thought being that getting that bit done and merged would be enabling for multiple problems.

[oxinabox]

I think even not supporting ] deved packages, but only the current active enviroment would be enough.
But regardless, we really should have something like this.

Here is some rough, untested code that might do it.
But it is slow because it uses stacktrace()
However maybe that's ok. If someone wants maximum speed, they can set depwarn=none
rather than proposesed new default setting of --depwarn=mine (or what ever we call it).
It is slow only when deprecations are hit, but the slowness doesn't depend on if it is there fault or not.

function is_author_file(path)
    # This might be tricked by stdlibs which seem to set file wrong in stacktraces
    
    # Put any directories we want to ignore here
    nonauthor_roots = joinpath.(Base.DEPOT_PATH, "packages")
    
    cur_path = path
    while ((cur_path=dirname(cur_path)) != "")
        dirname ∈ nonauthor_roots && return false
    end
    # coulnd't blame anyone else, must be our problem
    return true
end


function is_called_from_authors_code(log_emit_file)
    found_emit_file = false
    for frame in stacktrace()
        # Skip past helper code of logging system
        # with some thought and fragileness thsi could be removed and replaced with skipping first ~3 entries
        if !found_emit_file
            #not there yet
            if frame.file == log_emit_file
                found_emit_file = true
            end
            continue
        else
            # could insert logic here to handle deprecated 
            # methods called by other deprecated methods in the module
            # but skipping for now
            
            # Here we could be tricked by higher order functons
            # but skipping worrying about that for now
            # could put in a guard against at least the common ones like `map` and `sum` etc
            
            return is_author_file(frame.file)
        end
    end
    error("Failed to identify where function was used")
end

using LoggingExtras
ActiveFilteredLogger(global_logger()) do log
    log.group != :depwarn && return true  #pass nondepwarns straight on
    return is_called_from_authors_code(log.file)
end |> global_logger

I have never tested this code just putting it out there as a sketch of what the idea looks like really

Edit: we can probably decrease the cost a lot by only checking each deprecation warning once. Then for a given warning we don't have to check the stacktrace multiple times. This has two downsides: first if someone uses a deprecated function in two different places it will be hidden in one til Julia is restarted. Worse it you call a package that uses the deprecated function before you use it yourself you won't see it at all.

[oxinabox]

So the problem with my solution above is stacktrace() is incredibly expensive to call.
It takes about 40ms.
For comparison, just showing the log message (which takes too long to put in inner loops) takes 10us.

An alternative solution is to look at what packages are your direct dependencies.
We can build a set of them at start-up time or when they are loaded etc, or the first time a log message is printed
Then we just need to check at shouldlog time for if it has group=:depwarn and if _module is in this set. Which takes about 10ns.

The downside of this solution is it will give false positives.
If my active enviroment depends on A and B, and then B also depends on A,
and I call some method from B which calls a deprecated method from A we would still print a warning. But maybe that's acceptable.
Or we could take false negatives instead and only print if it is a package that is only a direct dependency. But that seems worse.

[oxinabox]

We could possibly use backtrace() rather than stacktrace() for catch look up purposes.

But it still seems to slow

julia> @btime stacktrace();
  40.065 ms (7584 allocations: 386.99 KiB)

julia> @btime backtrace();
  13.408 μs (48 allocations: 9.19 KiB)

[c42f]

I mean, it's 3000 times faster... Which may still be too slow?

[oxinabox]

10μs is what it costs to have it university turned on, and that is too slow.

[KristofferC]

10μs is what it costs to have it university turned on, and that is too slow.

I'm surprised by this number, doing something like:

julia> f() = Base.depwarn("foo", :foo)
f (generic function with 1 method)

julia> f()
┌ Warning: foo
│   caller = ip:0x0
└ @ Core :-1

julia> using BenchmarkTools

julia> @btime f()
  2.581 ms (286 allocations: 22.89 KiB)

shows a much larger performance penalty. And from what I understand, the slowness for this is precisely due to taking a backtrace and looking up some stuff in it (to show where the deprecated method was called from).