Debug.Log() in build

I have another alternative:

Create a custom "Debug" class in global space, that get's used in release builds only and make its Log methods conditional:

 #if DEBUG
 #define VERBOSE
 #endif
 
 #if !UNITY_EDITOR && !VERBOSE
 using UnityEngine;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 
 public static class Debug {
 
     [Conditional("VERBOSE_EXTRA")]
     public static void LogInfo(string message, UnityEngine.Object obj = null) {
         UnityEngine.Debug.Log(message, obj);
     }
 
     [Conditional("VERBOSE")]
     public static void Log(string message, UnityEngine.Object obj = null) {
         UnityEngine.Debug.Log(message, obj);
     }
 
     public static void LogWarning(string message, UnityEngine.Object obj = null) {
         UnityEngine.Debug.LogWarning(message, obj);
     }
 
     public static void LogError(string message, UnityEngine.Object obj = null) {
         UnityEngine.Debug.LogError(message, obj);
     }
 
     public static void LogException(System.Exception e) {
         UnityEngine.Debug.LogError(e.Message);
     }
 }
 #endif

The main advantage is, that the log usage doesn't differ at all, so it's easy to introduce it anytime:

 Debug.Log("Somethings going on here");

Note: I still want Warnings and Errors to be logged, so I didn't make them conditional. Starting with Unity 5.1, DEBUG gets defined automatically as soon as you create a development build.

Downside: UnityEngine.Debug methods other then Log, LogInfo, LogWarning and LogError have to be issued with the complete namespace. For example:

 UnityEngine.Debug.DrawLine(...);

This can easily be resolved by wrapping them all in our own Debug class. Feel free to do that, I simply was too lazy :)

My thoughts on how I got to this solution:

The solutions presented so far have one thing in common, they utilize an if statement. Downsides:

• you actually have to write it out on every log occasion.

• It generates an unnecessary evaluation at runtime.

You could argue that the impact of the if statement is minimal, but that didn't keep me from optimizing.

One way would be to use preprocessor directives, which totally work, but you'd still have to wrap every log statement with ugly code:

 #if DEBUG
     Debug.Log("Somethings going on here");
 #endif

To get rid of this I wrote my own class, which wrapped the Log calls with conditional methods. I assume the calls don't even exist in runtime assemblies. Something like that:

 public class Logging {
     [Conditional("DEBUG")]
     public static void Log(string message) {
         Debug.Log(message);
     }
 }

This works, but has these flaws:

• You have to change every "Debug.Log" call to "Logging.Log"

• In the Editor, you lose the feature of double clicking logs and jumping directly to the original place where the Log was issued, since you'll now end up in our new Logging class all the time. This is a major time waste.

Next step: rename the Logging class to "Debug". Since this new Debug class is in global namespace it automatically gets used instead of Unity's UnityEngine.Debug if you use it without the complete namespace when calling it. You now don't need to change Debug.Log calls at all, though the Editor click redirection still won't work.

Our Debug class now prevents Logs in non DEBUG environments. As the last step I put the whole class into preprocessor statements that enable it only outside the Editor in non development builds or if you add the scripting define symbol "VERBOSE".

I liked @atti 's solution, and decided to finish it off. Also added a few extra methods that auto concat args.

 #if DEBUG || UNITY_EDITOR
 #define VERBOSE
 #endif
 
 #if UNITY_EDITOR
 #define VERBOSE_EXTRA
 #endif
 
 using UnityEngine;
 using System.Diagnostics;
 using UnityEngine.Internal;
 using System;
 
 public static class Debug
 {
     //
     // Summary:
     //     Opens or closes developer console.
     public static bool developerConsoleVisible { get { return UnityEngine.Debug.developerConsoleVisible; } set { UnityEngine.Debug.developerConsoleVisible = value; } }
     //
     // Summary:
     //     In the Build Settings dialog there is a check box called "Development Build".
     public static bool isDebugBuild { get { return UnityEngine.Debug.isDebugBuild; } }
 
     //
     // Summary:
     //     Assert the condition.
     [Conditional("UNITY_ASSERTIONS")]
     public static void Assert(bool condition)
     {
         UnityEngine.Debug.Assert(condition);
     }
     //
     // Summary:
     //     Assert the condition.
     [Conditional("UNITY_ASSERTIONS")]
     public static void Assert(bool condition, string message)
     {
         UnityEngine.Debug.Assert(condition, message);
     }
     //
     // Summary:
     //     Assert the condition.
     [Conditional("UNITY_ASSERTIONS")]
     public static void Assert(bool condition, string format, params object[] args)
     {
         UnityEngine.Debug.Assert(condition, format, args);
     }
     public static void Break()
     {
         UnityEngine.Debug.Break();
     }
     public static void ClearDeveloperConsole()
     {
         UnityEngine.Debug.ClearDeveloperConsole();
     }
     public static void DebugBreak()
     {
         UnityEngine.Debug.DebugBreak();
     }
     //
     // Summary:
     //     Draws a line between specified start and end points.
     public static void DrawLine(Vector3 start, Vector3 end)
     {
         UnityEngine.Debug.DrawLine(start, end);
     }
     //
     // Summary:
     //     Draws a line between specified start and end points.
     public static void DrawLine(Vector3 start, Vector3 end, Color color)
     {
         UnityEngine.Debug.DrawLine(start, end, color);
     }
     //
     // Summary:
     //     Draws a line between specified start and end points.
     public static void DrawLine(Vector3 start, Vector3 end, Color color, float duration)
     {
         UnityEngine.Debug.DrawLine(start, end, color, duration);
     }
     //
     // Summary:
     //     Draws a line between specified start and end points.
     public static void DrawLine(Vector3 start, Vector3 end, [DefaultValue("Color.white")] Color color, [DefaultValue("0.0f")] float duration, [DefaultValue("true")] bool depthTest)
     {
         UnityEngine.Debug.DrawLine(start, end, color, duration, depthTest);
     }
     //
     // Summary:
     //     Draws a line from start to start + dir in world coordinates.
     public static void DrawRay(Vector3 start, Vector3 dir)
     {
         UnityEngine.Debug.DrawRay(start, dir);
     }
     //
     // Summary:
     //     Draws a line from start to start + dir in world coordinates.
     public static void DrawRay(Vector3 start, Vector3 dir, Color color)
     {
         UnityEngine.Debug.DrawRay(start, dir, color);
     }
     //
     // Summary:
     //     Draws a line from start to start + dir in world coordinates.
     public static void DrawRay(Vector3 start, Vector3 dir, Color color, float duration)
     {
         UnityEngine.Debug.DrawRay(start, dir, color, duration);
     }
     //
     // Summary:
     //     Draws a line from start to start + dir in world coordinates.
     public static void DrawRay(Vector3 start, Vector3 dir, [DefaultValue("Color.white")] Color color, [DefaultValue("0.0f")] float duration, [DefaultValue("true")] bool depthTest)
     {
         UnityEngine.Debug.DrawRay(start, dir, color, duration, depthTest);
     }
 
     [Conditional("VERBOSE_EXTRA")]
     public static void LogInfo(object message, UnityEngine.Object context = null)
     {
         UnityEngine.Debug.Log(message, context);
     }
     [Conditional("VERBOSE_EXTRA")]
     public static void LogInfoCat(params object[] args)
     {
         UnityEngine.Debug.Log(string.Concat(args));
     }
     //
     // Summary:
     //     Logs message to the Unity Console.
     [Conditional("VERBOSE")]
     public static void Log(object message, UnityEngine.Object context = null)
     {
         UnityEngine.Debug.Log(message, context);
     }
     //
     // Summary:
     //     Logs message to the Unity Console.
     [Conditional("VERBOSE")]
     public static void LogCat(params object[] args)
     {
         UnityEngine.Debug.Log(string.Concat(args));
     }
     //
     // Summary:
     //     A variant of Debug.Log that logs an error message to the console.
     public static void LogError(object message, UnityEngine.Object context = null)
     {
         UnityEngine.Debug.LogError(message, context);
     }
     //
     // Summary:
     //     A variant of Debug.Log that logs an error message to the console.
     public static void LogErrorCat(params object[] args)
     {
         UnityEngine.Debug.LogError(string.Concat(args));
     }
     //
     // Summary:
     //     Logs a formatted error message to the Unity console.
     public static void LogErrorFormat(string format, params object[] args)
     {
         UnityEngine.Debug.LogErrorFormat(format, args);
     }
     //
     // Summary:
     //     Logs a formatted error message to the Unity console.
     public static void LogErrorFormat(UnityEngine.Object context, string format, params object[] args)
     {
         UnityEngine.Debug.LogErrorFormat(context, format, args);
     }
     //
     // Summary:
     //     A variant of Debug.Log that logs an error message to the console.
     public static void LogException(Exception exception)
     {
         UnityEngine.Debug.LogException(exception);
     }
     //
     // Summary:
     //     A variant of Debug.Log that logs an error message to the console.
     public static void LogException(Exception exception, UnityEngine.Object context)
     {
         UnityEngine.Debug.LogException(exception, context);
     }
     //
     // Summary:
     //     Logs a formatted message to the Unity Console.
     [Conditional("VERBOSE")]
     public static void LogFormat(string format, params object[] args)
     {
         UnityEngine.Debug.LogFormat(format, args);
     }
     //
     // Summary:
     //     Logs a formatted message to the Unity Console.
     [Conditional("VERBOSE")]
     public static void LogFormat(UnityEngine.Object context, string format, params object[] args)
     {
         UnityEngine.Debug.LogFormat(context, format, args);
     }
     //
     // Summary:
     //     A variant of Debug.Log that logs a warning message to the console.
     public static void LogWarning(object message, UnityEngine.Object context = null)
     {
         UnityEngine.Debug.LogWarning(message, context);
     }
     //
     // Summary:
     //     A variant of Debug.Log that logs a warning message to the console.
     public static void LogWarningCat(params object[] args)
     {
         UnityEngine.Debug.LogWarning(string.Concat(args));
     }
     //
     // Summary:
     //     Logs a formatted warning message to the Unity Console.
     public static void LogWarningFormat(string format, params object[] args)
     {
         UnityEngine.Debug.LogWarningFormat(format, args);
     }
     //
     // Summary:
     //     Logs a formatted warning message to the Unity Console.
     public static void LogWarningFormat(UnityEngine.Object context, string format, params object[] args)
     {
         UnityEngine.Debug.LogWarningFormat(context, format, args);
     }
 }

Debug.Log() is still called when you are in a build so it could have an effect on performance depending on how much you call it. On iOS, it will actually log your information into the internal profiler if you are connected to xCode.

Removing them all is one option. I would just comment them out, or you can do this like the scripting ref suggests:

 // Log some debug information only if this is a debug build
 if (Debug.isDebugBuild) {
     Debug.Log ("This is a debug build!");
 }

I have definitely seen Debug.Log() be a performance problem. Even one can cause a little hiccup on a smallish platform if you have enough going on.

One thing I should mention that took me a little while to realize when I did a similar solution to your DebugLog() function is that often I would end up doing something like:

DebugLog("Here in Func() " + var1 + " / " + var2 + " / " + var3);

The string argument is evaluated whether or not you eventually log them, and they tend to be slow too - especially with concatenation. String.Format() is better, but still, I've come around to commenting these things out when not needed, and using #if UNITY_EDITOR for those I heavily rely on.