Descriptions for logging that exist in a class.

For .NET, how about PostSharp?
Free for commercial use (Can I use PostSharp Express for commercial products? on This page
The free version has functional limitations, but I think log output is sufficient.

I'm sorry for the C# example, but I'll use it like this:

 MyLogging
public class ClassX
{
    public int MethodA(...)
    {
        ...
    }
}

The MyLogging attribute inherits a class in the PostSharp library and creates it yourself.

public sold class MyLoggingAttribute:OnMethodBoundaryAspect
{
     public override void OnEntry (MethodExecutionArgsargs)
     {
         // be called before processing the target method
         // Arguments and instances of the target class are included in args.
     }
     public override void OnExit (MethodExecutionArgs args)
     {
         // Called after processing the target method (after return)
         // args is the same as OnEntry's, but there is also a return value.
     }
}

If you attach this attribute to a class, each time a method for that class is called, OnEntry and OnExit are called, so you can write log output processing or something like that.
If you attribute a method instead of a class, only that method can be logged out.

"However, I think some ingenuity is necessary to produce output like ""processing XX data."""
Make sure to return the number of cases with the return value...

PostSharp is available immediately after searching online in Visual Studio's Extensions and Updates.

As a supplement, there are many ways to implement the AOP framework, and PostSharp uses the method of "rewrite IL during build".
So, depending on the quantity, the build will be delayed.
However, compared to using proxy classes, there are no restrictions such as "must inherit a class" and performance at runtime is advantageous.

We introduce NLog to help you with your design examples or to consider replacing them with proprietary implementations.

using NLog;

public class MyClass
{
  private static Logger logger = LogManager.GetCurrentClassLogger();

  public void MyMethod1()
  {
    logger.Trace("Sample trace message");
    logger.Debug("Sample debug message");
    logger.Info("Sample informational message");
    logger.Warn("Sample warning message");
    logger.Error("Sample error message");
    logger.Fatal("Sample fatal error message");

    // alternately you can call the Log() method 
    // and pass log level as the parameter.
    logger.Log(LogLevel.Info, "Sample informational message");
  }
}

Logger is generated for static members of the class and utilized for each class.Other examples are well organized in Wiki, so please read them.
The log output processing to be written in the code is only at the log message and level (Fatal, Error, ...), and its output destination (Target) and format is controlled by NLog.Config.The design is clear and I like it.