nodejs
diff --git a/Collapse file
‎lib/internal/util/inspector.js‎
Copy file name to clipboardExpand all lines: lib/internal/util/inspector.js
+1-3Lines changed: 1 addition & 3 deletions b/Collapse file
‎lib/internal/util/inspector.js‎
Copy file name to clipboardExpand all lines: lib/internal/util/inspector.js
+1-3Lines changed: 1 addition & 3 deletions
diff --git a/Collapse file
‎src/env-inl.h‎
Copy file name to clipboardExpand all lines: src/env-inl.h
+10Lines changed: 10 additions & 0 deletions b/Collapse file
‎src/env-inl.h‎
Copy file name to clipboardExpand all lines: src/env-inl.h
+10Lines changed: 10 additions & 0 deletions
diff --git a/Collapse file
‎src/env.h‎
Copy file name to clipboardExpand all lines: src/env.h
+4Lines changed: 4 additions & 0 deletions b/Collapse file
‎src/env.h‎
Copy file name to clipboardExpand all lines: src/env.h
+4Lines changed: 4 additions & 0 deletions
diff --git a/Collapse file
‎src/inspector_js_api.cc‎
Copy file name to clipboardExpand all lines: src/inspector_js_api.cc
+8-17Lines changed: 8 additions & 17 deletions b/Collapse file
‎src/inspector_js_api.cc‎
Copy file name to clipboardExpand all lines: src/inspector_js_api.cc
+8-17Lines changed: 8 additions & 17 deletions
@@ -33,7 +33,6 @@ function installConsoleExtensions(commandLineApi) {
 
 // Wrap a console implemented by Node.js with features from the VM inspector
 function wrapConsole(consoleFromNode, consoleFromVM) {
-  const config = {};
   const { consoleCall } = internalBinding('inspector');
   for (const key of Object.keys(consoleFromVM)) {
     // If global console has the same method as inspector console,
@@ -42,8 +41,7 @@ function wrapConsole(consoleFromNode, consoleFromVM) {
     if (consoleFromNode.hasOwnProperty(key)) {
       consoleFromNode[key] = consoleCall.bind(consoleFromNode,
                                               consoleFromVM[key],
-                                              consoleFromNode[key],
-                                              config);
+                                              consoleFromNode[key]);
     } else {
       // Add additional console APIs from the inspector
       consoleFromNode[key] = consoleFromVM[key];
 
@@ -404,6 +404,16 @@ inline void Environment::TryLoadAddon(
   }
 }
 
+#if HAVE_INSPECTOR
+inline bool Environment::is_in_inspector_console_call() const {
+  return is_in_inspector_console_call_;
+}
+
+inline void Environment::set_is_in_inspector_console_call(bool value) {
+  is_in_inspector_console_call_ = value;
+}
+#endif
+
 inline Environment::AsyncHooks* Environment::async_hooks() {
   return &async_hooks_;
 }
 
@@ -874,6 +874,9 @@ class Environment {
   inline inspector::Agent* inspector_agent() const {
     return inspector_agent_.get();
   }
+
+  inline bool is_in_inspector_console_call() const;
+  inline void set_is_in_inspector_console_call(bool value);
 #endif
 
   typedef ListHead<HandleWrap, &HandleWrap::handle_wrap_queue_> HandleWrapQueue;
@@ -1043,6 +1046,7 @@ class Environment {
 
 #if HAVE_INSPECTOR
   std::unique_ptr<inspector::Agent> inspector_agent_;
+  bool is_in_inspector_console_call_ = false;
 #endif
 
   // handle_wrap_queue_ and req_wrap_queue_ needs to be at a fixed offset from
 
@@ -149,31 +149,22 @@ void InspectorConsoleCall(const FunctionCallbackInfo<Value>& info) {
   Environment* env = Environment::GetCurrent(info);
   Isolate* isolate = env->isolate();
   Local<Context> context = isolate->GetCurrentContext();
-  CHECK_LT(2, info.Length());
-  SlicedArguments call_args(info, /* start */ 3);
+  CHECK_GE(info.Length(), 2);
+  SlicedArguments call_args(info, /* start */ 2);
   if (InspectorEnabled(env)) {
     Local<Value> inspector_method = info[0];
     CHECK(inspector_method->IsFunction());
-    Local<Value> config_value = info[2];
-    CHECK(config_value->IsObject());
-    Local<Object> config_object = config_value.As<Object>();
-    Local<String> in_call_key = FIXED_ONE_BYTE_STRING(isolate, "in_call");
-    bool has_in_call;
-    if (!config_object->Has(context, in_call_key).To(&has_in_call))
-      return;
-    if (!has_in_call) {
-      if (config_object->Set(context,
-                             in_call_key,
-                             v8::True(isolate)).IsNothing() ||
+    if (!env->is_in_inspector_console_call()) {
+      env->set_is_in_inspector_console_call(true);
+      MaybeLocal<Value> ret =
           inspector_method.As<Function>()->Call(context,
                                                 info.Holder(),
                                                 call_args.length(),
-                                                call_args.out()).IsEmpty()) {
+                                                call_args.out());
+      env->set_is_in_inspector_console_call(false);
+      if (ret.IsEmpty())
         return;
-      }
     }
-    if (config_object->Delete(context, in_call_key).IsNothing())
-      return;
   }
 
   Local<Value> node_method = info[1];
Original file line number	Diff line number	Diff line change
`@@ -404,6 +404,16 @@ inline void Environment::TryLoadAddon(`
`404`	`404`	`}`
`405`	`405`	`}`
`406`	`406`
	`407`	`+#if HAVE_INSPECTOR`
	`408`	`+inline bool Environment::is_in_inspector_console_call() const {`
	`409`	`+ return is_in_inspector_console_call_;`
	`410`	`+}`
	`411`	`+`
	`412`	`+inline void Environment::set_is_in_inspector_console_call(bool value) {`
	`413`	`+ is_in_inspector_console_call_ = value;`
	`414`	`+}`
	`415`	`+#endif`
	`416`	`+`
`407`	`417`	`inline Environment::AsyncHooks* Environment::async_hooks() {`
`408`	`418`	`return &async_hooks_;`
`409`	`419`	`}`