具有最小圈复杂度的条件日志记录

Question

阅读“圈复杂度的限制是多少？”，我意识到我的许多同事对这个新的 我们项目的 QA 政策：不超过 10 圈复杂度< /a> 每个函数。

含义：不超过10个'if'、'else'、'try'、'catch'等代码工作流分支语句。 正确的。 正如我在“你测试私有方法吗？”中解释的那样，这样的政策有许多好的副作用。

但是：在我们的（200 人 - 7 年）项目开始时，我们很高兴记录（不，我们不能轻易地将其委托给某种“面向方面的编程'日志方法）。

myLogger.info("A String");
myLogger.fine("A more complicated String");
...

当我们系统的第一个版本上线时，我们遇到了巨大的内存问题，这不是因为日志记录（它一度被关闭），而是因为日志参数（字符串），这总是被计算，然后传递给“info()”或“fine()”函数，却发现日志记录级别为“OFF”，并且没有发生任何日志记录！

所以 QA 回来敦促我们的程序员进行条件日志记录。 总是。

if(myLogger.isLoggable(Level.INFO) { myLogger.info("A String");
if(myLogger.isLoggable(Level.FINE) { myLogger.fine("A more complicated String");
...

但现在，由于每个函数限制为“无法移动”10 圈复杂度级别，他们认为放入函数中的各种日志被认为是一种负担，因为每个“if(isLoggable())”都是算作 +1 圈复杂度！

因此，如果一个函数在一个紧密耦合的不易共享的算法中具有 8 个“if”、“else”等，以及 3 个关键日志操作……即使条件日志可能不是 < em>确实该功能的复杂性的一部分...

您将如何解决这种情况？
我在我的项目中看到了一些有趣的编码演变（由于“冲突”），但我只想先了解您的想法。

---

谢谢大家的回答。
我必须坚持认为问题不是与“格式”相关，而是与“参数评估”相关（在调用一个什么都不做的方法之前进行评估可能会非常昂贵）
因此，当 a 在上面写“A String”时，我实际上指的是 aFunction()，aFunction() 返回一个 String，并调用一个复杂的方法来收集和计算要由记录器显示的所有类型的日志数据......或不（因此出现问题，以及使用条件日志记录的义务，因此人为增加“圈复杂度”的实际问题......）

我现在得到“可变参数函数'由你们中的一些人提出（谢谢约翰）。
注意：java6 中的快速测试显示我的 varargs 函数< /a> 在调用之前会评估其参数，因此它不能应用于函数调用，但适用于“日志检索器对象”（或“函数包装器”），只有在需要时才会调用 toString() 。 知道了。

我现在已经发布了我在这个主题上的经验。
我会将其保留到下周二进行投票，然后我将选择您的答案之一。
再次感谢您的所有建议:)

Answer 1

对于当前的日志框架，问题是没有意义的。

当前的日志框架（如 slf4j 或 log4j 2）在大多数情况下不需要保护语句。 它们使用参数化日志语句，以便可以无条件记录事件，但仅在启用事件时才会进行消息格式化。 消息构造是由记录器根据需要执行的，而不是由应用程序抢先执行的。

如果您必须使用旧的日志记录库，您可以继续阅读以获取更多背景知识以及使用参数化消息改造旧库的方法。

保护语句真的增加了复杂性吗？

考虑从圈复杂度计算中排除日志保护语句。

可能有人会说，由于其可预测的形式，条件日志检查实际上不会增加​​代码的复杂性。

不灵活的指标可能会让原本优秀的程序员变坏。 当心！

假设您的计算复杂性的工具无法定制到这种程度，以下方法可能会提供解决方法。

条件日志记录的需要

我假设引入了 Guard 语句，因为您有这样的代码：

private static final Logger log = Logger.getLogger(MyClass.class);

Connection connect(Widget w, Dongle d, Dongle alt) 
  throws ConnectionException
{
  log.debug("Attempting connection of dongle " + d + " to widget " + w);
  Connection c;
  try {
    c = w.connect(d);
  } catch(ConnectionException ex) {
    log.warn("Connection failed; attempting alternate dongle " + d, ex);
    c = w.connect(alt);
  }
  log.debug("Connection succeeded: " + c);
  return c;
}

在 Java 中，每个日志语句都会创建一个新的 StringBuilder，并调用 toString()< /code> 每个对象上连接到字符串的方法。 这些 toString() 方法可能会创建自己的 StringBuilder 实例，并调用其成员的 toString() 方法，等等，跨越一个可能很大的对象图。 （在 Java 5 之前，它的成本甚至更高，因为使用了 StringBuffer，并且它的所有操作都是同步的。）

这可能相对昂贵，特别是如果日志语句位于某些执行频繁的代码中小路。 而且，如上所述，即使记录器由于日志级别太高而必然丢弃结果，也会发生昂贵的消息格式化。

这导致引入以下形式的保护语句：

  if (log.isDebugEnabled())
    log.debug("Attempting connection of dongle " + d + " to widget " + w);

使用此保护，仅在必要时才执行参数 d 和 w 的计算以及字符串连接。

简单、高效日志记录的解决方案

但是，如果记录器（或围绕所选日志记录包编写的包装器）采用格式化程序和格式化程序参数，则消息构造可能会延迟，直到确定将使用它为止，同时消除了守卫语句及其圈复杂度。

public final class FormatLogger
{

  private final Logger log;

  public FormatLogger(Logger log)
  {
    this.log = log;
  }

  public void debug(String formatter, Object... args)
  {
    log(Level.DEBUG, formatter, args);
  }

  … &c. for info, warn; also add overloads to log an exception …

  public void log(Level level, String formatter, Object... args)
  {
    if (log.isEnabled(level)) {
      /* 
       * Only now is the message constructed, and each "arg"
       * evaluated by having its toString() method invoked.
       */
      log.log(level, String.format(formatter, args));
    }
  }

}

class MyClass 
{

  private static final FormatLogger log = 
     new FormatLogger(Logger.getLogger(MyClass.class));

  Connection connect(Widget w, Dongle d, Dongle alt) 
    throws ConnectionException
  {
    log.debug("Attempting connection of dongle %s to widget %s.", d, w);
    Connection c;
    try {
      c = w.connect(d);
    } catch(ConnectionException ex) {
      log.warn("Connection failed; attempting alternate dongle %s.", d);
      c = w.connect(alt);
    }
    log.debug("Connection succeeded: %s", c);
    return c;
  }

}

现在，不会发生任何级联 toString() 调用及其缓冲区分配，除非有必要！ 这有效地消除了导致 Guard 语句的性能影响。 在 Java 中，一个小的缺点是对传递给记录器的任何基本类型参​​数进行自动装箱。

可以说，执行日志记录的代码比以往任何时候都更加干净，因为不整齐的字符串连接已经消失了。 如果格式字符串被外部化（使用ResourceBundle），它会更干净，这也有助于软件的维护或本地化。

进一步增强

另请注意，在 Java 中，可以使用 MessageFormat 对象代替“格式”String，它为您提供了额外的功能，例如选择要处理的格式基数更加整齐。 另一种选择是实现您自己的格式化功能，该功能调用您为“评估”定义的某些接口，而不是基本的 toString() 方法。

Answer 2

在 Python 中，您将格式化值作为参数传递给日志记录函数。 仅当启用日志记录时才应用字符串格式。 函数调用的开销仍然存在，但这与格式化相比微不足道。

log.info ("a = %s, b = %s", a, b)

您可以对任何具有可变参数的语言（C/C++、C#/Java 等）执行类似的操作。

---

这并不是真正适用于参数难以检索的情况，而是适用于将它们格式化为字符串的成本昂贵的情况。 例如，如果您的代码中已有数字列表，您可能需要记录该列表以进行调试。 执行 mylist.toString() 需要一段时间，但没有任何好处，因为结果将被丢弃。 因此，您将 mylist 作为参数传递给日志记录函数，并让它处理字符串格式。 这样，只有在需要时才会执行格式化。

---

由于OP的问题特别提到了Java，以下是如何使用上述内容：

我必须坚持认为问题与“格式”无关，而是与“参数评估”相关（在调用一个什么都不做的方法之前进行评估可能会非常昂贵）

诀窍是让对象不会执行昂贵的操作计算直到绝对需要为止。 这在 Smalltalk 或 Python 等支持 lambda 和闭包的语言中很容易实现，但在 Java 中只要发挥一点想象力也是可行的。

假设您有一个函数 get_everything()。 它将把数据库中的每个对象检索到列表中。 显然，如果结果将被丢弃，您不想调用它。 因此，您不是直接使用对该函数的调用，而是定义一个名为 LazyGetEverything 的内部类：

public class MainClass {
    private class LazyGetEverything { 
        @Override
        public String toString() { 
            return getEverything().toString(); 
        }
    }

    private Object getEverything() {
        /* returns what you want to .toString() in the inner class */
    }

    public void logEverything() {
        log.info(new LazyGetEverything());
    }
}

在此代码中，对 getEverything() 的调用进行了包装，以便它不会“直到需要时才会真正执行。 仅当启用调试时，日志记录函数才会对其参数执行toString()。 这样，您的代码将只承受函数调用的开销，而不是完整的 getEverything() 调用。

Answer 3

在支持 lambda 表达式或代码块作为参数的语言中，一种解决方案是将其提供给日志记录方法。 该人可以评估配置，并且仅在需要时才实际调用/执行提供的 lambda/代码块。
不过还没有尝试过。

理论上这是可能的。 我不想在生产中使用它，因为我预计大量使用 lamdas/代码块进行日志记录会出现性能问题。

但一如既往：如果有疑问，请对其进行测试并测量对 CPU 负载和内存的影响。

Answer 4

感谢您的所有回答！ 你们太棒了:)

现在我的反馈并不像你们的那么直接：

是的，对于一个项目（例如“在一个生产平台上独立部署和运行一个程序”），我假设您可以对我进行所有技术操作：

• 专用的“Log Retriever”对象，可以传递给 Logger 包装器，只需调用 toString()
• 与日志记录结合使用即可。 org/wiki/Variadic_function" rel="nofollow noreferrer">可变参数函数（或普通的 Object[] 数组！），

就这样，正如 @John Millikin 和 @erickson 所解释的那样。

然而，这个问题迫使我们思考一下“我们到底为什么要首先登录？”
我们的项目实际上是30个不同的项目（每个5到10人）部署在各种生产平台上，具有异步通信需求和中央总线架构。
问题中描述的简单日志记录对于每个项目在开始时（5 年前）来说都很好，但从那时起，我们必须加强。 输入KPI。

我们不要求记录器记录任何内容，而是要求自动创建的对象（称为 KPI）注册事件。 这是一个简单的调用（myKPI.I_am_signaling_myself_to_you()），并且不需要有条件（这解决了“人工增加圈复杂度”问题）。

该 KPI 对象知道谁调用它，并且由于他从应用程序的开头运行，因此他能够检索我们之前在记录时当场计算的大量数据。
另外，可以独立监控 KPI 对象，并在单个单独的发布总线上按需计算/发布其信息。
这样，每个客户端都可以询问他真正想要的信息（例如，“我的流程是否开始了，如果是，从什么时候开始？”），而不是寻找正确的日志文件并查找神秘的字符串......

确实，问题“我们到底为什么要登录？” 让我们意识到我们不仅仅为程序员及其单元或集成测试进行日志记录，而是为更广泛的社区（包括一些最终客户本身）进行日志记录。 我们的“报告”机制必须是集中的、异步的、24/7 的。

该 KPI 机制的具体内容超出了本问题的范围。 可以说，它的正确校准是迄今为止我们面临的最复杂的非功能性问题。 它仍然时不时地让系统崩溃！ 然而，经过适当校准，它可以挽救生命。

再次感谢您的所有建议。 当简单的日志记录仍然存在时，我们将在系统的某些部分考虑它们。
但这个问题的另一点是在更大、更复杂的背景下向您说明一个具体问题。
希望你喜欢它。 下周晚些时候我可能会问一个关于 KPI 的问题（不管你信不信，到目前为止，SOF 上没有任何问题！）。

我会将这个答案留到下周二进行投票，然后我将选择一个答案（显然不是这个；））

Answer 5

也许这太简单了，但是围绕保护子句使用“提取方法”重构怎么样？ 您的示例代码：

public void Example()
{
  if(myLogger.isLoggable(Level.INFO))
      myLogger.info("A String");
  if(myLogger.isLoggable(Level.FINE))
      myLogger.fine("A more complicated String");
  // +1 for each test and log message
}

变成这样：

public void Example()
{
   _LogInfo();
   _LogFine();
   // +0 for each test and log message
}

private void _LogInfo()
{
   if(!myLogger.isLoggable(Level.INFO))
      return;

   // Do your complex argument calculations/evaluations only when needed.
}

private void _LogFine(){ /* Ditto ... */ }

Answer 6

在 C 或 C++ 中，我将使用预处理器而不是 if 语句来进行条件日志记录。

Answer 7

将日志级别传递给记录器并让它决定是否写入日志语句：

//if(myLogger.isLoggable(Level.INFO) {myLogger.info("A String");
myLogger.info(Level.INFO,"A String");

更新：啊，我看到您想有条件地创建日志字符串，而不需要条件语句。 大概是在运行时而不是编译时。

我只想说，我们解决这个问题的方法是将格式化代码放入记录器类中，以便只有在级别通过时才会进行格式化。 与内置 sprintf 非常相似。 例如：

myLogger.info(Level.INFO,"A String %d",some_number);   

这应该符合您的标准。

Answer 8

条件日志记录是邪恶的。 它给你的代码增加了不必要的混乱。

您应该始终将拥有的对象发送到记录器：

Logger logger = ...
logger.log(Level.DEBUG,"The foo is {0} and the bar is {1}",new Object[]{foo, bar});

然后使用 java.util.logging.Formatter 使用 MessageFormat 将 foo 和 bar 展平为要输出的字符串。 仅当记录器和处理程序在该级别记录时才会调用它。

为了增加乐趣，您可以使用某种表达式语言来精细控制如何格式化记录的对象（toString 可能并不总是有用）。

Answer 9

_{（来源：scala-lang.org）}

Scala 有一个注释 @elidable() 允许您删除带有编译器标志的方法。

使用 scala REPL：

C:>scala

欢迎使用 Scala 版本 2.8.0.final（Java HotSpot(TM) 64 位服务器 VM，Java 1。
6.0_16)。
输入表达式以对其进行求值。
输入 :help 以获取更多信息。

scala> 导入 scala.annotation.elidable
导入 scala.annotation.elidable

scala> 导入 scala.annotation.elidable._
导入scala.annotation.elidable._

scala> @elidable(FINE) def logDebug(arg :String) = println(arg)

logDebug：（参数：字符串）单位

scala> logDebug(“测试”)

scala>

带 elide-beloset

C:>scala -Xelide-低于 0

欢迎使用 Scala 版本 2.8.0.final（Java HotSpot(TM) 64 位服务器 VM，Java 1。
6.0_16)。
输入表达式以对其进行求值。
输入 :help 以获取更多信息。

scala> 导入 scala.annotation.elidable
导入 scala.annotation.elidable

scala> 导入 scala.annotation.elidable._
导入scala.annotation.elidable._

scala> @elidable(FINE) def logDebug(arg :String) = println(arg)

logDebug：（参数：字符串）单位

scala> logDebug(“测试”)

测试

scala>

另请参阅 Scala 断言定义

Answer 10

尽管我讨厌 C/C++ 中的宏，但在工作中，我们有 if 部分的#defines，如果为 false，则忽略（不计算）以下表达式，但如果为 true，则返回一个流，可以使用 ' 将内容传输到该流中<<' 操作员。
像这样：

LOGGER(LEVEL_INFO) << "A String";

我认为这将消除您的工具所看到的额外“复杂性”，并且还消除了对字符串的任何计算，或者在未达到级别时要记录的任何表达式。

Answer 11

这是一个使用三元表达式的优雅解决方案

logger.info(logger.isInfoEnabled() ? "Log Statement gone here..." : null);

Answer 12

考虑一个日志实用程序函数...

void debugUtil(String s, Object… args) {
   if (LOG.isDebugEnabled())
       LOG.debug(s, args);
   }
);

然后使用“闭包”来调用您想要避免的昂贵的评估。

debugUtil(“We got a %s”, new Object() {
       @Override String toString() { 
       // only evaluated if the debug statement is executed
           return expensiveCallToGetSomeValue().toString;
       }
    }
);