This article is a part of basic procedures.

How to differentiate between development and production builds

Default project configuration in modern IDEs has 3 build configurations defined:

The supposed meaning is:

Default build configurations

You can also check current build configuration in your source code:

{$IFDEF DEBUG}
ShowMessage('Development build');
{$ELSE}
ShowMessage('Production build');
{$ENDIF}

We recommend to follow that approach.

See also: EurekaLog does not work when compiling "Release" profile in C++ Builder.

Note: if you are using old IDE without build configurations support - the alternative way would be to create two projects, which will include the same set of units and share the same project source (.dpr file). Assign one project to be a development project, and second project to be a production project. The example below would use modern IDE as an example.

Important: do not forget to make a full project rebuild (not just compile) when you have switched active build configuration.

Short Answer

You can improve detalization of your bug reports by selecting the proper project options. This articles explain various project options related to debugging and a recommended choices.

Note: exact options names and locations depend on your IDE version. The specific option may be called differently or be located in other place in your IDE.

Important: if you are linking with the run-time packages - we highly recommend to remove EurekaLogCore package from the run-time packages list. Linking with the EurekaLogCore package is designed for special use cases, it should not be used in generic cases.

Notes:

Long Answer

We can give a recommendations for different use cases. These recommendations are written down below. Settings which differs from defaults are marked in bold (i.e. you should toggle items in bold manually).

EurekaLog-enabled application

1. BASE SETTINGS FOR EACH BUILD CONFIGURATION

2a. DEBUG BUILD CONFIGURATION (Local Debugging)

2b. RELEASE BUILD CONFIGURATION (Production)

Note: if you don't do many index-based operations (so additional checks will not slow down your code) - then it may be a good idea to always keep "Range checking" on.

Note: your code or 3rd party code (i.e.: non-standard components) may use compiler directives in source code, which affect the options above. For example, a component may have {$D-} directive inside its .pas units to exclude itself from debugging. Obviously, doing so will prevent EurekaLog from getting descriptions for this component. You may need to change the source code and edit/remove such directives.

Usual application (without EurekaLog)

1. BASE SETTINGS FOR EACH BUILD CONFIGURATION

2a. DEBUG BUILD CONFIGURATION (Local Debugging)

2b. RELEASE BUILD CONFIGURATION (Production)

Detailed explanation of options

Note: we'll talk about project options in this article. We will not talk about EurekaLog project options. You can open project options via "Project" / "Options" IDE menu command.

Warning: please, remember that you need to make a full build (and not just "compile"), if you change any of these options.

We're interested in "Compiling" and "Linking" pages:

Compiling page (Delphi)

C++ Compiler/Debugging page (C++ Builder)

On "Compiling" page, we are interested in:

Linking page (Delphi)

C++ Linker page (C++ Builder)

C++ Linker/Output page (C++ Builder)

On "Linking" page, we are interested in:

What do these options mean?

The most important settings are set of options "Debug information" ("Compiling" page).

The program is array of machine's (CPU) instructions - which are just bytes (numbers). The source code is a text file. The question: how does the debugger know, when he needs to stop, when you are setting a breakpoint in your source? Where is correspondence between raw numbers and human-readable text?

This correspondence is a debug information. Roughly speaking, the debug information is set of instructions like: "the machine codes no. 1056-1059 correspond to line 234 of Unit1". The debugger works thanks to such debug info.

And these options? They controls the generation of debug information for your units.

The debug information is stored in dcu-files together with its compiled code. I.e. the very same Unit1.pas can be compiled into different dcu-files (with or without debug information). The debug information increases compilation time, size of dcu-files, but it does not affect size or speed of resulting application (i.e. debug information is not included into application).

There are cases, when you want to have debug information in your files or (at least) near them. For example: if you are going to do remote debugging or debugging of external process. OR if you want to have human-readable call-stack in your exception diagnostic tool (EurekaLog).

EurekaLog takes care of injecting debug information into your executable. This work is performed by IDE expert or command-line compiler.

However, project options affects detalization of debug information. So, you need to set project options properly to maximize result.

Let's do a short overview what these options do (see also: Compiling page and Linking page in Delphi's help and C++ Compiler page and C++ Linker page in C++ Builder's help). Most important options are marked in bold.

Those options are very close related and usually there is no need to enable or disable only one of them - they are switched together.

Note: some of these options can be enabled not only globally, but also separately for each unit (several options can affect single routines or, even, lines of code). This is done by using usual compiler directives (you can see them in help). For example, "Stack Frames" is controlled by {$W+} and {$W-} and Debug information from Compiling page is controlled by {$D+} and {$D-}.

See also: